701 SET_SHARED_LIBRARY_ORIGIN
702 CXX_FLAG_REORDER
703 C_FLAG_REORDER
704 SET_SHARED_LIBRARY_MAPFILE
705 SET_SHARED_LIBRARY_NAME
706 SHARED_LIBRARY_FLAGS
707 EXE_SUFFIX
708 STATIC_LIBRARY_SUFFIX
709 SHARED_LIBRARY_SUFFIX
710 LIBRARY_PREFIX
711 STATIC_LIBRARY
712 SHARED_LIBRARY
713 OBJ_SUFFIX
714 COMPILER_NAME
715 JT_HOME
716 JTREGEXE
717 ac_ct_OBJDUMP
718 OBJDUMP
719 ac_ct_OBJCOPY
720 OBJCOPY
721 OTOOL
722 MCS
723 STRIP
724 GNM
725 NM
726 AS
727 CXXCPP
728 CPP
729 COMPILER_TYPE
730 RC_FLAGS
731 DUMPBIN
732 WINAR
733 HOTSPOT_RC
734 HOTSPOT_MT
735 RC
736 MT
737 WINLD
738 HOTSPOT_LD
739 HOTSPOT_CXX
740 ARFLAGS
741 AR
742 LDEXECXX
743 LDCXX
744 LDEXE
745 LD
746 ac_ct_OBJC
747 OBJCFLAGS
748 OBJC
749 CXX_VERSION
750 CC_VERSION
751 ac_ct_CXX
752 CXXFLAGS
753 CXX
754 ac_ct_PROPER_COMPILER_CXX
755 PROPER_COMPILER_CXX
756 POTENTIAL_CXX
757 TOOLS_DIR_CXX
758 COMPILER_TARGET_BITS_FLAG
759 OBJEXT
760 EXEEXT
908 OPENJDK_BUILD_OS_API
909 OPENJDK_BUILD_OS
910 OPENJDK_BUILD_AUTOCONF_NAME
911 OPENJDK_TARGET_AUTOCONF_NAME
912 target_os
913 target_vendor
914 target_cpu
915 target
916 host_os
917 host_vendor
918 host_cpu
919 host
920 build_os
921 build_vendor
922 build_cpu
923 build
924 SETFILE
925 DF
926 READLINK
927 CYGPATH
928 NAWK
929 SED
930 FGREP
931 EGREP
932 GREP
933 AWK
934 XARGS
935 WHICH
936 WC
937 UNIQ
938 UNAME
939 TR
940 TOUCH
941 TEE
942 TAR
943 TAIL
944 SORT
945 SH
946 RM
947 PRINTF
948 MV
949 MKTEMP
950 MKDIR
951 LS
952 LN
953 HEAD
954 FIND
955 FILE
956 EXPR
957 ECHO
958 DIRNAME
959 DIFF
960 DATE
961 CUT
962 CPIO
963 CP
964 COMM
965 CMP
966 CHMOD
967 CAT
1069 with_freetype_lib
1070 enable_freetype_bundling
1071 with_alsa
1072 with_alsa_include
1073 with_alsa_lib
1074 with_giflib
1075 with_zlib
1076 with_stdc__lib
1077 with_num_cores
1078 with_memory_size
1079 with_jobs
1080 with_sjavac_server_java
1081 enable_sjavac
1082 enable_precompiled_headers
1083 enable_ccache
1084 with_ccache_dir
1085 '
1086 ac_precious_vars='build_alias
1087 host_alias
1088 target_alias
1089 PKG_CONFIG
1090 CC
1091 CFLAGS
1092 LDFLAGS
1093 LIBS
1094 CPPFLAGS
1095 CXX
1096 CXXFLAGS
1097 CCC
1098 OBJC
1099 OBJCFLAGS
1100 CPP
1101 CXXCPP
1102 XMKMF
1103 FREETYPE_CFLAGS
1104 FREETYPE_LIBS
1105 ALSA_CFLAGS
1106 ALSA_LIBS
1107 LIBFFI_CFLAGS
1108 LIBFFI_LIBS'
1109
1110
1111 # Initialize some variables set by options.
1112 ac_init_help=
1113 ac_init_version=false
1114 ac_unrecognized_opts=
1115 ac_unrecognized_sep=
1116 # The variables have the same names as the options, with
1117 # dashes changed to underlines.
1118 cache_file=/dev/null
1119 exec_prefix=NONE
1120 no_create=
1121 no_recursion=
1122 prefix=NONE
1123 program_prefix=NONE
1124 program_suffix=NONE
1125 program_transform_name=s,x,x,
1126 silent=
1127 site=
1128 srcdir=
1847 --with-giflib use giflib from build system or OpenJDK source
1848 (system, bundled) [bundled]
1849 --with-zlib use zlib from build system or OpenJDK source
1850 (system, bundled) [bundled]
1851 --with-stdc++lib=<static>,<dynamic>,<default>
1852 force linking of the C++ runtime on Linux to either
1853 static or dynamic, default is static with dynamic as
1854 fallback
1855 --with-num-cores number of cores in the build system, e.g.
1856 --with-num-cores=8 [probed]
1857 --with-memory-size memory (in MB) available in the build system, e.g.
1858 --with-memory-size=1024 [probed]
1859 --with-jobs number of parallel jobs to let make run [calculated
1860 based on cores and memory]
1861 --with-sjavac-server-java
1862 use this java binary for running the sjavac
1863 background server [Boot JDK java]
1864 --with-ccache-dir where to store ccache files [~/.ccache]
1865
1866 Some influential environment variables:
1867 PKG_CONFIG path to pkg-config utility
1868 CC C compiler command
1869 CFLAGS C compiler flags
1870 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
1871 nonstandard directory <lib dir>
1872 LIBS libraries to pass to the linker, e.g. -l<library>
1873 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1874 you have headers in a nonstandard directory <include dir>
1875 CXX C++ compiler command
1876 CXXFLAGS C++ compiler flags
1877 OBJC Objective C compiler command
1878 OBJCFLAGS Objective C compiler flags
1879 CPP C preprocessor
1880 CXXCPP C++ preprocessor
1881 XMKMF Path to xmkmf, Makefile generator for X Window System
1882 FREETYPE_CFLAGS
1883 C compiler flags for FREETYPE, overriding pkg-config
1884 FREETYPE_LIBS
1885 linker flags for FREETYPE, overriding pkg-config
1886 ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
1887 ALSA_LIBS linker flags for ALSA, overriding pkg-config
1888 LIBFFI_CFLAGS
1889 C compiler flags for LIBFFI, overriding pkg-config
1890 LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
1891
1892 Use these variables to override the choices made by `configure' or to help
1893 it to find libraries and programs with nonstandard names/locations.
1894
1895 Report bugs to <build-dev@openjdk.java.net>.
1896 OpenJDK home page: <http://openjdk.java.net>.
1897 _ACEOF
1898 ac_status=$?
1899 fi
1900
1901 if test "$ac_init_help" = "recursive"; then
1902 # If there are subdirs, report their specific --help.
1903 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1904 test -d "$ac_dir" ||
1905 { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
1906 continue
1907 ac_builddir=.
1908
1909 case "$ac_dir" in
1910 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
3173 # If the input variable does not have a directory specification, then
3174 # it need to be in the PATH.
3175 # $1: The name of the variable to fix
3176
3177
3178
3179
3180 # Register a --with argument but mark it as deprecated
3181 # $1: The name of the with argument to deprecate, not including --with-
3182
3183
3184 # Register a --enable argument but mark it as deprecated
3185 # $1: The name of the with argument to deprecate, not including --enable-
3186 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3187
3188
3189
3190
3191 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3192 # $1: variable to check
3193 # $2: executable name to print in warning (optional)
3194
3195
3196 # Does AC_PATH_PROG followed by BASIC_CHECK_NONEMPTY.
3197 # Arguments as AC_PATH_PROG:
3198 # $1: variable to set
3199 # $2: executable name to look for
3200
3201
3202 # Setup the most fundamental tools that relies on not much else to set up,
3203 # but is used by much of the early bootstrap code.
3204
3205
3206 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3207
3208
3209
3210
3211
3212
3213
3214 #%%% Simple tools %%%
3215
3216 # Check if we have found a usable version of make
3217 # $1: the path to a potential make binary (or empty)
3218 # $2: the description on how we found this
3219
3895 # Check if the VS env variables were setup prior to running configure.
3896 # If not, then find vcvarsall.bat and run it automatically, and integrate
3897 # the set env variables into the spec file.
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909 # This line needs to be here, verbatim, after all includes and the dummy hook
3910 # definitions. It is replaced with custom functionality when building
3911 # custom sources.
3912 #CUSTOM_AUTOCONF_INCLUDE
3913
3914 # Do not change or remove the following line, it is needed for consistency checks:
3915 DATE_WHEN_GENERATED=1521218818
3916
3917 ###############################################################################
3918 #
3919 # Initialization / Boot-strapping
3920 #
3921 # The bootstrapping process needs to solve the "chicken or the egg" problem,
3922 # thus it jumps back and forth, each time gaining something needed later on.
3923 #
3924 ###############################################################################
3925
3926 # Basic initialization that must happen first of all
3927
3928 # Save the original command line. This is passed to us by the wrapper configure script.
3929
3930 DATE_WHEN_CONFIGURED=`LANG=C date`
3931
3932 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
3933 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
3934 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
3935 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
3936
3937
3938
3939 # Start with tools that do not need have cross compilation support
3940 # and can be expected to be found in the default PATH. These tools are
3941 # used by configure. Nor are these tools expected to be found in the
3942 # devkit from the builddeps server either, since they are
3943 # needed to download the devkit.
3944
3945 # First are all the simple required tools.
3946
3947 for ac_prog in basename
3948 do
3949 # Extract the first word of "$ac_prog", so it can be a program name with args.
3950 set dummy $ac_prog; ac_word=$2
3951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3952 $as_echo_n "checking for $ac_word... " >&6; }
3953 if ${ac_cv_path_BASENAME+:} false; then :
3954 $as_echo_n "(cached) " >&6
3955 else
3956 case $BASENAME in
3957 [\\/]* | ?:[\\/]*)
3958 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
3959 ;;
3960 *)
3961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3962 for as_dir in $PATH
3963 do
3964 IFS=$as_save_IFS
3965 test -z "$as_dir" && as_dir=.
3966 for ac_exec_ext in '' $ac_executable_extensions; do
3972 done
3973 done
3974 IFS=$as_save_IFS
3975
3976 ;;
3977 esac
3978 fi
3979 BASENAME=$ac_cv_path_BASENAME
3980 if test -n "$BASENAME"; then
3981 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
3982 $as_echo "$BASENAME" >&6; }
3983 else
3984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3985 $as_echo "no" >&6; }
3986 fi
3987
3988
3989 test -n "$BASENAME" && break
3990 done
3991
3992
3993 if test "x$BASENAME" = x; then
3994 if test "xbasename" = x; then
3995 PROG_NAME=basename
3996 else
3997 PROG_NAME=basename
3998 fi
3999 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4000 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4001 as_fn_error $? "Cannot continue" "$LINENO" 5
4002 fi
4003
4004
4005
4006 for ac_prog in bash
4007 do
4008 # Extract the first word of "$ac_prog", so it can be a program name with args.
4009 set dummy $ac_prog; ac_word=$2
4010 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4011 $as_echo_n "checking for $ac_word... " >&6; }
4012 if ${ac_cv_path_BASH+:} false; then :
4013 $as_echo_n "(cached) " >&6
4014 else
4015 case $BASH in
4016 [\\/]* | ?:[\\/]*)
4017 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4018 ;;
4019 *)
4020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4021 for as_dir in $PATH
4022 do
4023 IFS=$as_save_IFS
4024 test -z "$as_dir" && as_dir=.
4025 for ac_exec_ext in '' $ac_executable_extensions; do
4026 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4027 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4028 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4029 break 2
4030 fi
4031 done
4032 done
4033 IFS=$as_save_IFS
4034
4035 ;;
4036 esac
4037 fi
4038 BASH=$ac_cv_path_BASH
4039 if test -n "$BASH"; then
4040 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4041 $as_echo "$BASH" >&6; }
4042 else
4043 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4044 $as_echo "no" >&6; }
4045 fi
4046
4047
4048 test -n "$BASH" && break
4049 done
4050
4051
4052 if test "x$BASH" = x; then
4053 if test "xbash" = x; then
4054 PROG_NAME=bash
4055 else
4056 PROG_NAME=bash
4057 fi
4058 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4059 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4060 as_fn_error $? "Cannot continue" "$LINENO" 5
4061 fi
4062
4063
4064
4065 for ac_prog in cat
4066 do
4067 # Extract the first word of "$ac_prog", so it can be a program name with args.
4068 set dummy $ac_prog; ac_word=$2
4069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4070 $as_echo_n "checking for $ac_word... " >&6; }
4071 if ${ac_cv_path_CAT+:} false; then :
4072 $as_echo_n "(cached) " >&6
4073 else
4074 case $CAT in
4075 [\\/]* | ?:[\\/]*)
4076 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4077 ;;
4078 *)
4079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4080 for as_dir in $PATH
4081 do
4082 IFS=$as_save_IFS
4083 test -z "$as_dir" && as_dir=.
4084 for ac_exec_ext in '' $ac_executable_extensions; do
4085 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4086 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4087 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4088 break 2
4089 fi
4090 done
4091 done
4092 IFS=$as_save_IFS
4093
4094 ;;
4095 esac
4096 fi
4097 CAT=$ac_cv_path_CAT
4098 if test -n "$CAT"; then
4099 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4100 $as_echo "$CAT" >&6; }
4101 else
4102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4103 $as_echo "no" >&6; }
4104 fi
4105
4106
4107 test -n "$CAT" && break
4108 done
4109
4110
4111 if test "x$CAT" = x; then
4112 if test "xcat" = x; then
4113 PROG_NAME=cat
4114 else
4115 PROG_NAME=cat
4116 fi
4117 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4118 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4119 as_fn_error $? "Cannot continue" "$LINENO" 5
4120 fi
4121
4122
4123
4124 for ac_prog in chmod
4125 do
4126 # Extract the first word of "$ac_prog", so it can be a program name with args.
4127 set dummy $ac_prog; ac_word=$2
4128 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4129 $as_echo_n "checking for $ac_word... " >&6; }
4130 if ${ac_cv_path_CHMOD+:} false; then :
4131 $as_echo_n "(cached) " >&6
4132 else
4133 case $CHMOD in
4134 [\\/]* | ?:[\\/]*)
4135 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4136 ;;
4137 *)
4138 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4139 for as_dir in $PATH
4140 do
4141 IFS=$as_save_IFS
4142 test -z "$as_dir" && as_dir=.
4143 for ac_exec_ext in '' $ac_executable_extensions; do
4144 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4145 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4146 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4147 break 2
4148 fi
4149 done
4150 done
4151 IFS=$as_save_IFS
4152
4153 ;;
4154 esac
4155 fi
4156 CHMOD=$ac_cv_path_CHMOD
4157 if test -n "$CHMOD"; then
4158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4159 $as_echo "$CHMOD" >&6; }
4160 else
4161 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4162 $as_echo "no" >&6; }
4163 fi
4164
4165
4166 test -n "$CHMOD" && break
4167 done
4168
4169
4170 if test "x$CHMOD" = x; then
4171 if test "xchmod" = x; then
4172 PROG_NAME=chmod
4173 else
4174 PROG_NAME=chmod
4175 fi
4176 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4177 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4178 as_fn_error $? "Cannot continue" "$LINENO" 5
4179 fi
4180
4181
4182
4183 for ac_prog in cmp
4184 do
4185 # Extract the first word of "$ac_prog", so it can be a program name with args.
4186 set dummy $ac_prog; ac_word=$2
4187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4188 $as_echo_n "checking for $ac_word... " >&6; }
4189 if ${ac_cv_path_CMP+:} false; then :
4190 $as_echo_n "(cached) " >&6
4191 else
4192 case $CMP in
4193 [\\/]* | ?:[\\/]*)
4194 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
4195 ;;
4196 *)
4197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4198 for as_dir in $PATH
4199 do
4200 IFS=$as_save_IFS
4201 test -z "$as_dir" && as_dir=.
4202 for ac_exec_ext in '' $ac_executable_extensions; do
4203 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4204 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
4205 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4206 break 2
4207 fi
4208 done
4209 done
4210 IFS=$as_save_IFS
4211
4212 ;;
4213 esac
4214 fi
4215 CMP=$ac_cv_path_CMP
4216 if test -n "$CMP"; then
4217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
4218 $as_echo "$CMP" >&6; }
4219 else
4220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4221 $as_echo "no" >&6; }
4222 fi
4223
4224
4225 test -n "$CMP" && break
4226 done
4227
4228
4229 if test "x$CMP" = x; then
4230 if test "xcmp" = x; then
4231 PROG_NAME=cmp
4232 else
4233 PROG_NAME=cmp
4234 fi
4235 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4236 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4237 as_fn_error $? "Cannot continue" "$LINENO" 5
4238 fi
4239
4240
4241
4242 for ac_prog in comm
4243 do
4244 # Extract the first word of "$ac_prog", so it can be a program name with args.
4245 set dummy $ac_prog; ac_word=$2
4246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4247 $as_echo_n "checking for $ac_word... " >&6; }
4248 if ${ac_cv_path_COMM+:} false; then :
4249 $as_echo_n "(cached) " >&6
4250 else
4251 case $COMM in
4252 [\\/]* | ?:[\\/]*)
4253 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
4254 ;;
4255 *)
4256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4257 for as_dir in $PATH
4258 do
4259 IFS=$as_save_IFS
4260 test -z "$as_dir" && as_dir=.
4261 for ac_exec_ext in '' $ac_executable_extensions; do
4262 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4263 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
4264 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4265 break 2
4266 fi
4267 done
4268 done
4269 IFS=$as_save_IFS
4270
4271 ;;
4272 esac
4273 fi
4274 COMM=$ac_cv_path_COMM
4275 if test -n "$COMM"; then
4276 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
4277 $as_echo "$COMM" >&6; }
4278 else
4279 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4280 $as_echo "no" >&6; }
4281 fi
4282
4283
4284 test -n "$COMM" && break
4285 done
4286
4287
4288 if test "x$COMM" = x; then
4289 if test "xcomm" = x; then
4290 PROG_NAME=comm
4291 else
4292 PROG_NAME=comm
4293 fi
4294 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4295 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4296 as_fn_error $? "Cannot continue" "$LINENO" 5
4297 fi
4298
4299
4300
4301 for ac_prog in cp
4302 do
4303 # Extract the first word of "$ac_prog", so it can be a program name with args.
4304 set dummy $ac_prog; ac_word=$2
4305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4306 $as_echo_n "checking for $ac_word... " >&6; }
4307 if ${ac_cv_path_CP+:} false; then :
4308 $as_echo_n "(cached) " >&6
4309 else
4310 case $CP in
4311 [\\/]* | ?:[\\/]*)
4312 ac_cv_path_CP="$CP" # Let the user override the test with a path.
4313 ;;
4314 *)
4315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4316 for as_dir in $PATH
4317 do
4318 IFS=$as_save_IFS
4319 test -z "$as_dir" && as_dir=.
4320 for ac_exec_ext in '' $ac_executable_extensions; do
4321 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4322 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
4323 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4324 break 2
4325 fi
4326 done
4327 done
4328 IFS=$as_save_IFS
4329
4330 ;;
4331 esac
4332 fi
4333 CP=$ac_cv_path_CP
4334 if test -n "$CP"; then
4335 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
4336 $as_echo "$CP" >&6; }
4337 else
4338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4339 $as_echo "no" >&6; }
4340 fi
4341
4342
4343 test -n "$CP" && break
4344 done
4345
4346
4347 if test "x$CP" = x; then
4348 if test "xcp" = x; then
4349 PROG_NAME=cp
4350 else
4351 PROG_NAME=cp
4352 fi
4353 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4354 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4355 as_fn_error $? "Cannot continue" "$LINENO" 5
4356 fi
4357
4358
4359
4360 for ac_prog in cpio
4361 do
4362 # Extract the first word of "$ac_prog", so it can be a program name with args.
4363 set dummy $ac_prog; ac_word=$2
4364 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4365 $as_echo_n "checking for $ac_word... " >&6; }
4366 if ${ac_cv_path_CPIO+:} false; then :
4367 $as_echo_n "(cached) " >&6
4368 else
4369 case $CPIO in
4370 [\\/]* | ?:[\\/]*)
4371 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
4372 ;;
4373 *)
4374 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4375 for as_dir in $PATH
4376 do
4377 IFS=$as_save_IFS
4378 test -z "$as_dir" && as_dir=.
4379 for ac_exec_ext in '' $ac_executable_extensions; do
4380 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4381 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
4382 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4383 break 2
4384 fi
4385 done
4386 done
4387 IFS=$as_save_IFS
4388
4389 ;;
4390 esac
4391 fi
4392 CPIO=$ac_cv_path_CPIO
4393 if test -n "$CPIO"; then
4394 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
4395 $as_echo "$CPIO" >&6; }
4396 else
4397 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4398 $as_echo "no" >&6; }
4399 fi
4400
4401
4402 test -n "$CPIO" && break
4403 done
4404
4405
4406 if test "x$CPIO" = x; then
4407 if test "xcpio" = x; then
4408 PROG_NAME=cpio
4409 else
4410 PROG_NAME=cpio
4411 fi
4412 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4413 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4414 as_fn_error $? "Cannot continue" "$LINENO" 5
4415 fi
4416
4417
4418
4419 for ac_prog in cut
4420 do
4421 # Extract the first word of "$ac_prog", so it can be a program name with args.
4422 set dummy $ac_prog; ac_word=$2
4423 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4424 $as_echo_n "checking for $ac_word... " >&6; }
4425 if ${ac_cv_path_CUT+:} false; then :
4426 $as_echo_n "(cached) " >&6
4427 else
4428 case $CUT in
4429 [\\/]* | ?:[\\/]*)
4430 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
4431 ;;
4432 *)
4433 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4434 for as_dir in $PATH
4435 do
4436 IFS=$as_save_IFS
4437 test -z "$as_dir" && as_dir=.
4438 for ac_exec_ext in '' $ac_executable_extensions; do
4439 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4440 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
4441 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4442 break 2
4443 fi
4444 done
4445 done
4446 IFS=$as_save_IFS
4447
4448 ;;
4449 esac
4450 fi
4451 CUT=$ac_cv_path_CUT
4452 if test -n "$CUT"; then
4453 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
4454 $as_echo "$CUT" >&6; }
4455 else
4456 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4457 $as_echo "no" >&6; }
4458 fi
4459
4460
4461 test -n "$CUT" && break
4462 done
4463
4464
4465 if test "x$CUT" = x; then
4466 if test "xcut" = x; then
4467 PROG_NAME=cut
4468 else
4469 PROG_NAME=cut
4470 fi
4471 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4472 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4473 as_fn_error $? "Cannot continue" "$LINENO" 5
4474 fi
4475
4476
4477
4478 for ac_prog in date
4479 do
4480 # Extract the first word of "$ac_prog", so it can be a program name with args.
4481 set dummy $ac_prog; ac_word=$2
4482 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4483 $as_echo_n "checking for $ac_word... " >&6; }
4484 if ${ac_cv_path_DATE+:} false; then :
4485 $as_echo_n "(cached) " >&6
4486 else
4487 case $DATE in
4488 [\\/]* | ?:[\\/]*)
4489 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
4490 ;;
4491 *)
4492 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4493 for as_dir in $PATH
4494 do
4495 IFS=$as_save_IFS
4496 test -z "$as_dir" && as_dir=.
4497 for ac_exec_ext in '' $ac_executable_extensions; do
4498 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4499 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
4500 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4501 break 2
4502 fi
4503 done
4504 done
4505 IFS=$as_save_IFS
4506
4507 ;;
4508 esac
4509 fi
4510 DATE=$ac_cv_path_DATE
4511 if test -n "$DATE"; then
4512 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
4513 $as_echo "$DATE" >&6; }
4514 else
4515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4516 $as_echo "no" >&6; }
4517 fi
4518
4519
4520 test -n "$DATE" && break
4521 done
4522
4523
4524 if test "x$DATE" = x; then
4525 if test "xdate" = x; then
4526 PROG_NAME=date
4527 else
4528 PROG_NAME=date
4529 fi
4530 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4531 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4532 as_fn_error $? "Cannot continue" "$LINENO" 5
4533 fi
4534
4535
4536
4537 for ac_prog in gdiff diff
4538 do
4539 # Extract the first word of "$ac_prog", so it can be a program name with args.
4540 set dummy $ac_prog; ac_word=$2
4541 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4542 $as_echo_n "checking for $ac_word... " >&6; }
4543 if ${ac_cv_path_DIFF+:} false; then :
4544 $as_echo_n "(cached) " >&6
4545 else
4546 case $DIFF in
4547 [\\/]* | ?:[\\/]*)
4548 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
4549 ;;
4550 *)
4551 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4552 for as_dir in $PATH
4553 do
4554 IFS=$as_save_IFS
4555 test -z "$as_dir" && as_dir=.
4556 for ac_exec_ext in '' $ac_executable_extensions; do
4557 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4558 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
4559 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4560 break 2
4561 fi
4562 done
4563 done
4564 IFS=$as_save_IFS
4565
4566 ;;
4567 esac
4568 fi
4569 DIFF=$ac_cv_path_DIFF
4570 if test -n "$DIFF"; then
4571 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
4572 $as_echo "$DIFF" >&6; }
4573 else
4574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4575 $as_echo "no" >&6; }
4576 fi
4577
4578
4579 test -n "$DIFF" && break
4580 done
4581
4582
4583 if test "x$DIFF" = x; then
4584 if test "xgdiff diff" = x; then
4585 PROG_NAME=diff
4586 else
4587 PROG_NAME=gdiff diff
4588 fi
4589 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4590 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4591 as_fn_error $? "Cannot continue" "$LINENO" 5
4592 fi
4593
4594
4595
4596 for ac_prog in dirname
4597 do
4598 # Extract the first word of "$ac_prog", so it can be a program name with args.
4599 set dummy $ac_prog; ac_word=$2
4600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4601 $as_echo_n "checking for $ac_word... " >&6; }
4602 if ${ac_cv_path_DIRNAME+:} false; then :
4603 $as_echo_n "(cached) " >&6
4604 else
4605 case $DIRNAME in
4606 [\\/]* | ?:[\\/]*)
4607 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
4608 ;;
4609 *)
4610 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4611 for as_dir in $PATH
4612 do
4613 IFS=$as_save_IFS
4614 test -z "$as_dir" && as_dir=.
4615 for ac_exec_ext in '' $ac_executable_extensions; do
4616 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4617 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
4618 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4619 break 2
4620 fi
4621 done
4622 done
4623 IFS=$as_save_IFS
4624
4625 ;;
4626 esac
4627 fi
4628 DIRNAME=$ac_cv_path_DIRNAME
4629 if test -n "$DIRNAME"; then
4630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
4631 $as_echo "$DIRNAME" >&6; }
4632 else
4633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4634 $as_echo "no" >&6; }
4635 fi
4636
4637
4638 test -n "$DIRNAME" && break
4639 done
4640
4641
4642 if test "x$DIRNAME" = x; then
4643 if test "xdirname" = x; then
4644 PROG_NAME=dirname
4645 else
4646 PROG_NAME=dirname
4647 fi
4648 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4649 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4650 as_fn_error $? "Cannot continue" "$LINENO" 5
4651 fi
4652
4653
4654
4655 for ac_prog in echo
4656 do
4657 # Extract the first word of "$ac_prog", so it can be a program name with args.
4658 set dummy $ac_prog; ac_word=$2
4659 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4660 $as_echo_n "checking for $ac_word... " >&6; }
4661 if ${ac_cv_path_ECHO+:} false; then :
4662 $as_echo_n "(cached) " >&6
4663 else
4664 case $ECHO in
4665 [\\/]* | ?:[\\/]*)
4666 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
4667 ;;
4668 *)
4669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4670 for as_dir in $PATH
4671 do
4672 IFS=$as_save_IFS
4673 test -z "$as_dir" && as_dir=.
4674 for ac_exec_ext in '' $ac_executable_extensions; do
4675 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4676 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
4677 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4678 break 2
4679 fi
4680 done
4681 done
4682 IFS=$as_save_IFS
4683
4684 ;;
4685 esac
4686 fi
4687 ECHO=$ac_cv_path_ECHO
4688 if test -n "$ECHO"; then
4689 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
4690 $as_echo "$ECHO" >&6; }
4691 else
4692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4693 $as_echo "no" >&6; }
4694 fi
4695
4696
4697 test -n "$ECHO" && break
4698 done
4699
4700
4701 if test "x$ECHO" = x; then
4702 if test "xecho" = x; then
4703 PROG_NAME=echo
4704 else
4705 PROG_NAME=echo
4706 fi
4707 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4708 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4709 as_fn_error $? "Cannot continue" "$LINENO" 5
4710 fi
4711
4712
4713
4714 for ac_prog in expr
4715 do
4716 # Extract the first word of "$ac_prog", so it can be a program name with args.
4717 set dummy $ac_prog; ac_word=$2
4718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4719 $as_echo_n "checking for $ac_word... " >&6; }
4720 if ${ac_cv_path_EXPR+:} false; then :
4721 $as_echo_n "(cached) " >&6
4722 else
4723 case $EXPR in
4724 [\\/]* | ?:[\\/]*)
4725 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
4726 ;;
4727 *)
4728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4729 for as_dir in $PATH
4730 do
4731 IFS=$as_save_IFS
4732 test -z "$as_dir" && as_dir=.
4733 for ac_exec_ext in '' $ac_executable_extensions; do
4734 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4735 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
4736 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4737 break 2
4738 fi
4739 done
4740 done
4741 IFS=$as_save_IFS
4742
4743 ;;
4744 esac
4745 fi
4746 EXPR=$ac_cv_path_EXPR
4747 if test -n "$EXPR"; then
4748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
4749 $as_echo "$EXPR" >&6; }
4750 else
4751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4752 $as_echo "no" >&6; }
4753 fi
4754
4755
4756 test -n "$EXPR" && break
4757 done
4758
4759
4760 if test "x$EXPR" = x; then
4761 if test "xexpr" = x; then
4762 PROG_NAME=expr
4763 else
4764 PROG_NAME=expr
4765 fi
4766 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4767 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4768 as_fn_error $? "Cannot continue" "$LINENO" 5
4769 fi
4770
4771
4772
4773 for ac_prog in file
4774 do
4775 # Extract the first word of "$ac_prog", so it can be a program name with args.
4776 set dummy $ac_prog; ac_word=$2
4777 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4778 $as_echo_n "checking for $ac_word... " >&6; }
4779 if ${ac_cv_path_FILE+:} false; then :
4780 $as_echo_n "(cached) " >&6
4781 else
4782 case $FILE in
4783 [\\/]* | ?:[\\/]*)
4784 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
4785 ;;
4786 *)
4787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4788 for as_dir in $PATH
4789 do
4790 IFS=$as_save_IFS
4791 test -z "$as_dir" && as_dir=.
4792 for ac_exec_ext in '' $ac_executable_extensions; do
4793 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4794 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
4795 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4796 break 2
4797 fi
4798 done
4799 done
4800 IFS=$as_save_IFS
4801
4802 ;;
4803 esac
4804 fi
4805 FILE=$ac_cv_path_FILE
4806 if test -n "$FILE"; then
4807 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
4808 $as_echo "$FILE" >&6; }
4809 else
4810 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4811 $as_echo "no" >&6; }
4812 fi
4813
4814
4815 test -n "$FILE" && break
4816 done
4817
4818
4819 if test "x$FILE" = x; then
4820 if test "xfile" = x; then
4821 PROG_NAME=file
4822 else
4823 PROG_NAME=file
4824 fi
4825 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4826 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4827 as_fn_error $? "Cannot continue" "$LINENO" 5
4828 fi
4829
4830
4831
4832 for ac_prog in find
4833 do
4834 # Extract the first word of "$ac_prog", so it can be a program name with args.
4835 set dummy $ac_prog; ac_word=$2
4836 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4837 $as_echo_n "checking for $ac_word... " >&6; }
4838 if ${ac_cv_path_FIND+:} false; then :
4839 $as_echo_n "(cached) " >&6
4840 else
4841 case $FIND in
4842 [\\/]* | ?:[\\/]*)
4843 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
4844 ;;
4845 *)
4846 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4847 for as_dir in $PATH
4848 do
4849 IFS=$as_save_IFS
4850 test -z "$as_dir" && as_dir=.
4851 for ac_exec_ext in '' $ac_executable_extensions; do
4852 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4853 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
4854 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4855 break 2
4856 fi
4857 done
4858 done
4859 IFS=$as_save_IFS
4860
4861 ;;
4862 esac
4863 fi
4864 FIND=$ac_cv_path_FIND
4865 if test -n "$FIND"; then
4866 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
4867 $as_echo "$FIND" >&6; }
4868 else
4869 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4870 $as_echo "no" >&6; }
4871 fi
4872
4873
4874 test -n "$FIND" && break
4875 done
4876
4877
4878 if test "x$FIND" = x; then
4879 if test "xfind" = x; then
4880 PROG_NAME=find
4881 else
4882 PROG_NAME=find
4883 fi
4884 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4885 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4886 as_fn_error $? "Cannot continue" "$LINENO" 5
4887 fi
4888
4889
4890
4891 for ac_prog in head
4892 do
4893 # Extract the first word of "$ac_prog", so it can be a program name with args.
4894 set dummy $ac_prog; ac_word=$2
4895 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4896 $as_echo_n "checking for $ac_word... " >&6; }
4897 if ${ac_cv_path_HEAD+:} false; then :
4898 $as_echo_n "(cached) " >&6
4899 else
4900 case $HEAD in
4901 [\\/]* | ?:[\\/]*)
4902 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
4903 ;;
4904 *)
4905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4906 for as_dir in $PATH
4907 do
4908 IFS=$as_save_IFS
4909 test -z "$as_dir" && as_dir=.
4910 for ac_exec_ext in '' $ac_executable_extensions; do
4911 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4912 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
4913 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4914 break 2
4915 fi
4916 done
4917 done
4918 IFS=$as_save_IFS
4919
4920 ;;
4921 esac
4922 fi
4923 HEAD=$ac_cv_path_HEAD
4924 if test -n "$HEAD"; then
4925 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
4926 $as_echo "$HEAD" >&6; }
4927 else
4928 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4929 $as_echo "no" >&6; }
4930 fi
4931
4932
4933 test -n "$HEAD" && break
4934 done
4935
4936
4937 if test "x$HEAD" = x; then
4938 if test "xhead" = x; then
4939 PROG_NAME=head
4940 else
4941 PROG_NAME=head
4942 fi
4943 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
4944 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
4945 as_fn_error $? "Cannot continue" "$LINENO" 5
4946 fi
4947
4948
4949
4950 for ac_prog in ln
4951 do
4952 # Extract the first word of "$ac_prog", so it can be a program name with args.
4953 set dummy $ac_prog; ac_word=$2
4954 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4955 $as_echo_n "checking for $ac_word... " >&6; }
4956 if ${ac_cv_path_LN+:} false; then :
4957 $as_echo_n "(cached) " >&6
4958 else
4959 case $LN in
4960 [\\/]* | ?:[\\/]*)
4961 ac_cv_path_LN="$LN" # Let the user override the test with a path.
4962 ;;
4963 *)
4964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4965 for as_dir in $PATH
4966 do
4967 IFS=$as_save_IFS
4968 test -z "$as_dir" && as_dir=.
4969 for ac_exec_ext in '' $ac_executable_extensions; do
4970 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4971 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
4972 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4973 break 2
4974 fi
4975 done
4976 done
4977 IFS=$as_save_IFS
4978
4979 ;;
4980 esac
4981 fi
4982 LN=$ac_cv_path_LN
4983 if test -n "$LN"; then
4984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
4985 $as_echo "$LN" >&6; }
4986 else
4987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4988 $as_echo "no" >&6; }
4989 fi
4990
4991
4992 test -n "$LN" && break
4993 done
4994
4995
4996 if test "x$LN" = x; then
4997 if test "xln" = x; then
4998 PROG_NAME=ln
4999 else
5000 PROG_NAME=ln
5001 fi
5002 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5003 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5004 as_fn_error $? "Cannot continue" "$LINENO" 5
5005 fi
5006
5007
5008
5009 for ac_prog in ls
5010 do
5011 # Extract the first word of "$ac_prog", so it can be a program name with args.
5012 set dummy $ac_prog; ac_word=$2
5013 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5014 $as_echo_n "checking for $ac_word... " >&6; }
5015 if ${ac_cv_path_LS+:} false; then :
5016 $as_echo_n "(cached) " >&6
5017 else
5018 case $LS in
5019 [\\/]* | ?:[\\/]*)
5020 ac_cv_path_LS="$LS" # Let the user override the test with a path.
5021 ;;
5022 *)
5023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5024 for as_dir in $PATH
5025 do
5026 IFS=$as_save_IFS
5027 test -z "$as_dir" && as_dir=.
5028 for ac_exec_ext in '' $ac_executable_extensions; do
5029 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5030 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
5031 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5032 break 2
5033 fi
5034 done
5035 done
5036 IFS=$as_save_IFS
5037
5038 ;;
5039 esac
5040 fi
5041 LS=$ac_cv_path_LS
5042 if test -n "$LS"; then
5043 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
5044 $as_echo "$LS" >&6; }
5045 else
5046 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5047 $as_echo "no" >&6; }
5048 fi
5049
5050
5051 test -n "$LS" && break
5052 done
5053
5054
5055 if test "x$LS" = x; then
5056 if test "xls" = x; then
5057 PROG_NAME=ls
5058 else
5059 PROG_NAME=ls
5060 fi
5061 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5062 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5063 as_fn_error $? "Cannot continue" "$LINENO" 5
5064 fi
5065
5066
5067
5068 for ac_prog in mkdir
5069 do
5070 # Extract the first word of "$ac_prog", so it can be a program name with args.
5071 set dummy $ac_prog; ac_word=$2
5072 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5073 $as_echo_n "checking for $ac_word... " >&6; }
5074 if ${ac_cv_path_MKDIR+:} false; then :
5075 $as_echo_n "(cached) " >&6
5076 else
5077 case $MKDIR in
5078 [\\/]* | ?:[\\/]*)
5079 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
5080 ;;
5081 *)
5082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5083 for as_dir in $PATH
5084 do
5085 IFS=$as_save_IFS
5086 test -z "$as_dir" && as_dir=.
5087 for ac_exec_ext in '' $ac_executable_extensions; do
5088 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5089 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
5090 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5091 break 2
5092 fi
5093 done
5094 done
5095 IFS=$as_save_IFS
5096
5097 ;;
5098 esac
5099 fi
5100 MKDIR=$ac_cv_path_MKDIR
5101 if test -n "$MKDIR"; then
5102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
5103 $as_echo "$MKDIR" >&6; }
5104 else
5105 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5106 $as_echo "no" >&6; }
5107 fi
5108
5109
5110 test -n "$MKDIR" && break
5111 done
5112
5113
5114 if test "x$MKDIR" = x; then
5115 if test "xmkdir" = x; then
5116 PROG_NAME=mkdir
5117 else
5118 PROG_NAME=mkdir
5119 fi
5120 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5121 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5122 as_fn_error $? "Cannot continue" "$LINENO" 5
5123 fi
5124
5125
5126
5127 for ac_prog in mktemp
5128 do
5129 # Extract the first word of "$ac_prog", so it can be a program name with args.
5130 set dummy $ac_prog; ac_word=$2
5131 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5132 $as_echo_n "checking for $ac_word... " >&6; }
5133 if ${ac_cv_path_MKTEMP+:} false; then :
5134 $as_echo_n "(cached) " >&6
5135 else
5136 case $MKTEMP in
5137 [\\/]* | ?:[\\/]*)
5138 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
5139 ;;
5140 *)
5141 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5142 for as_dir in $PATH
5143 do
5144 IFS=$as_save_IFS
5145 test -z "$as_dir" && as_dir=.
5146 for ac_exec_ext in '' $ac_executable_extensions; do
5147 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5148 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
5149 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5150 break 2
5151 fi
5152 done
5153 done
5154 IFS=$as_save_IFS
5155
5156 ;;
5157 esac
5158 fi
5159 MKTEMP=$ac_cv_path_MKTEMP
5160 if test -n "$MKTEMP"; then
5161 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
5162 $as_echo "$MKTEMP" >&6; }
5163 else
5164 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5165 $as_echo "no" >&6; }
5166 fi
5167
5168
5169 test -n "$MKTEMP" && break
5170 done
5171
5172
5173 if test "x$MKTEMP" = x; then
5174 if test "xmktemp" = x; then
5175 PROG_NAME=mktemp
5176 else
5177 PROG_NAME=mktemp
5178 fi
5179 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5180 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5181 as_fn_error $? "Cannot continue" "$LINENO" 5
5182 fi
5183
5184
5185
5186 for ac_prog in mv
5187 do
5188 # Extract the first word of "$ac_prog", so it can be a program name with args.
5189 set dummy $ac_prog; ac_word=$2
5190 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5191 $as_echo_n "checking for $ac_word... " >&6; }
5192 if ${ac_cv_path_MV+:} false; then :
5193 $as_echo_n "(cached) " >&6
5194 else
5195 case $MV in
5196 [\\/]* | ?:[\\/]*)
5197 ac_cv_path_MV="$MV" # Let the user override the test with a path.
5198 ;;
5199 *)
5200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5201 for as_dir in $PATH
5202 do
5203 IFS=$as_save_IFS
5204 test -z "$as_dir" && as_dir=.
5205 for ac_exec_ext in '' $ac_executable_extensions; do
5206 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5207 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
5208 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5209 break 2
5210 fi
5211 done
5212 done
5213 IFS=$as_save_IFS
5214
5215 ;;
5216 esac
5217 fi
5218 MV=$ac_cv_path_MV
5219 if test -n "$MV"; then
5220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
5221 $as_echo "$MV" >&6; }
5222 else
5223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5224 $as_echo "no" >&6; }
5225 fi
5226
5227
5228 test -n "$MV" && break
5229 done
5230
5231
5232 if test "x$MV" = x; then
5233 if test "xmv" = x; then
5234 PROG_NAME=mv
5235 else
5236 PROG_NAME=mv
5237 fi
5238 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5239 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5240 as_fn_error $? "Cannot continue" "$LINENO" 5
5241 fi
5242
5243
5244
5245 for ac_prog in printf
5246 do
5247 # Extract the first word of "$ac_prog", so it can be a program name with args.
5248 set dummy $ac_prog; ac_word=$2
5249 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5250 $as_echo_n "checking for $ac_word... " >&6; }
5251 if ${ac_cv_path_PRINTF+:} false; then :
5252 $as_echo_n "(cached) " >&6
5253 else
5254 case $PRINTF in
5255 [\\/]* | ?:[\\/]*)
5256 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
5257 ;;
5258 *)
5259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5260 for as_dir in $PATH
5261 do
5262 IFS=$as_save_IFS
5263 test -z "$as_dir" && as_dir=.
5264 for ac_exec_ext in '' $ac_executable_extensions; do
5265 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5266 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
5267 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5268 break 2
5269 fi
5270 done
5271 done
5272 IFS=$as_save_IFS
5273
5274 ;;
5275 esac
5276 fi
5277 PRINTF=$ac_cv_path_PRINTF
5278 if test -n "$PRINTF"; then
5279 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
5280 $as_echo "$PRINTF" >&6; }
5281 else
5282 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5283 $as_echo "no" >&6; }
5284 fi
5285
5286
5287 test -n "$PRINTF" && break
5288 done
5289
5290
5291 if test "x$PRINTF" = x; then
5292 if test "xprintf" = x; then
5293 PROG_NAME=printf
5294 else
5295 PROG_NAME=printf
5296 fi
5297 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5298 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5299 as_fn_error $? "Cannot continue" "$LINENO" 5
5300 fi
5301
5302
5303
5304 for ac_prog in rm
5305 do
5306 # Extract the first word of "$ac_prog", so it can be a program name with args.
5307 set dummy $ac_prog; ac_word=$2
5308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5309 $as_echo_n "checking for $ac_word... " >&6; }
5310 if ${ac_cv_path_RM+:} false; then :
5311 $as_echo_n "(cached) " >&6
5312 else
5313 case $RM in
5314 [\\/]* | ?:[\\/]*)
5315 ac_cv_path_RM="$RM" # Let the user override the test with a path.
5316 ;;
5317 *)
5318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5319 for as_dir in $PATH
5320 do
5321 IFS=$as_save_IFS
5322 test -z "$as_dir" && as_dir=.
5323 for ac_exec_ext in '' $ac_executable_extensions; do
5324 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5325 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
5326 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5327 break 2
5328 fi
5329 done
5330 done
5331 IFS=$as_save_IFS
5332
5333 ;;
5334 esac
5335 fi
5336 RM=$ac_cv_path_RM
5337 if test -n "$RM"; then
5338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
5339 $as_echo "$RM" >&6; }
5340 else
5341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5342 $as_echo "no" >&6; }
5343 fi
5344
5345
5346 test -n "$RM" && break
5347 done
5348
5349
5350 if test "x$RM" = x; then
5351 if test "xrm" = x; then
5352 PROG_NAME=rm
5353 else
5354 PROG_NAME=rm
5355 fi
5356 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5357 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5358 as_fn_error $? "Cannot continue" "$LINENO" 5
5359 fi
5360
5361
5362
5363 for ac_prog in sh
5364 do
5365 # Extract the first word of "$ac_prog", so it can be a program name with args.
5366 set dummy $ac_prog; ac_word=$2
5367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5368 $as_echo_n "checking for $ac_word... " >&6; }
5369 if ${ac_cv_path_SH+:} false; then :
5370 $as_echo_n "(cached) " >&6
5371 else
5372 case $SH in
5373 [\\/]* | ?:[\\/]*)
5374 ac_cv_path_SH="$SH" # Let the user override the test with a path.
5375 ;;
5376 *)
5377 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5378 for as_dir in $PATH
5379 do
5380 IFS=$as_save_IFS
5381 test -z "$as_dir" && as_dir=.
5382 for ac_exec_ext in '' $ac_executable_extensions; do
5383 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5384 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
5385 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5386 break 2
5387 fi
5388 done
5389 done
5390 IFS=$as_save_IFS
5391
5392 ;;
5393 esac
5394 fi
5395 SH=$ac_cv_path_SH
5396 if test -n "$SH"; then
5397 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
5398 $as_echo "$SH" >&6; }
5399 else
5400 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5401 $as_echo "no" >&6; }
5402 fi
5403
5404
5405 test -n "$SH" && break
5406 done
5407
5408
5409 if test "x$SH" = x; then
5410 if test "xsh" = x; then
5411 PROG_NAME=sh
5412 else
5413 PROG_NAME=sh
5414 fi
5415 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5416 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5417 as_fn_error $? "Cannot continue" "$LINENO" 5
5418 fi
5419
5420
5421
5422 for ac_prog in sort
5423 do
5424 # Extract the first word of "$ac_prog", so it can be a program name with args.
5425 set dummy $ac_prog; ac_word=$2
5426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5427 $as_echo_n "checking for $ac_word... " >&6; }
5428 if ${ac_cv_path_SORT+:} false; then :
5429 $as_echo_n "(cached) " >&6
5430 else
5431 case $SORT in
5432 [\\/]* | ?:[\\/]*)
5433 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
5434 ;;
5435 *)
5436 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5437 for as_dir in $PATH
5438 do
5439 IFS=$as_save_IFS
5440 test -z "$as_dir" && as_dir=.
5441 for ac_exec_ext in '' $ac_executable_extensions; do
5442 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5443 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
5444 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5445 break 2
5446 fi
5447 done
5448 done
5449 IFS=$as_save_IFS
5450
5451 ;;
5452 esac
5453 fi
5454 SORT=$ac_cv_path_SORT
5455 if test -n "$SORT"; then
5456 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
5457 $as_echo "$SORT" >&6; }
5458 else
5459 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5460 $as_echo "no" >&6; }
5461 fi
5462
5463
5464 test -n "$SORT" && break
5465 done
5466
5467
5468 if test "x$SORT" = x; then
5469 if test "xsort" = x; then
5470 PROG_NAME=sort
5471 else
5472 PROG_NAME=sort
5473 fi
5474 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5475 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5476 as_fn_error $? "Cannot continue" "$LINENO" 5
5477 fi
5478
5479
5480
5481 for ac_prog in tail
5482 do
5483 # Extract the first word of "$ac_prog", so it can be a program name with args.
5484 set dummy $ac_prog; ac_word=$2
5485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5486 $as_echo_n "checking for $ac_word... " >&6; }
5487 if ${ac_cv_path_TAIL+:} false; then :
5488 $as_echo_n "(cached) " >&6
5489 else
5490 case $TAIL in
5491 [\\/]* | ?:[\\/]*)
5492 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
5493 ;;
5494 *)
5495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5496 for as_dir in $PATH
5497 do
5498 IFS=$as_save_IFS
5499 test -z "$as_dir" && as_dir=.
5500 for ac_exec_ext in '' $ac_executable_extensions; do
5501 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5502 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
5503 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5504 break 2
5505 fi
5506 done
5507 done
5508 IFS=$as_save_IFS
5509
5510 ;;
5511 esac
5512 fi
5513 TAIL=$ac_cv_path_TAIL
5514 if test -n "$TAIL"; then
5515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
5516 $as_echo "$TAIL" >&6; }
5517 else
5518 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5519 $as_echo "no" >&6; }
5520 fi
5521
5522
5523 test -n "$TAIL" && break
5524 done
5525
5526
5527 if test "x$TAIL" = x; then
5528 if test "xtail" = x; then
5529 PROG_NAME=tail
5530 else
5531 PROG_NAME=tail
5532 fi
5533 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5534 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5535 as_fn_error $? "Cannot continue" "$LINENO" 5
5536 fi
5537
5538
5539
5540 for ac_prog in tar
5541 do
5542 # Extract the first word of "$ac_prog", so it can be a program name with args.
5543 set dummy $ac_prog; ac_word=$2
5544 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5545 $as_echo_n "checking for $ac_word... " >&6; }
5546 if ${ac_cv_path_TAR+:} false; then :
5547 $as_echo_n "(cached) " >&6
5548 else
5549 case $TAR in
5550 [\\/]* | ?:[\\/]*)
5551 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
5552 ;;
5553 *)
5554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5555 for as_dir in $PATH
5556 do
5557 IFS=$as_save_IFS
5558 test -z "$as_dir" && as_dir=.
5559 for ac_exec_ext in '' $ac_executable_extensions; do
5560 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5561 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
5562 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5563 break 2
5564 fi
5565 done
5566 done
5567 IFS=$as_save_IFS
5568
5569 ;;
5570 esac
5571 fi
5572 TAR=$ac_cv_path_TAR
5573 if test -n "$TAR"; then
5574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
5575 $as_echo "$TAR" >&6; }
5576 else
5577 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5578 $as_echo "no" >&6; }
5579 fi
5580
5581
5582 test -n "$TAR" && break
5583 done
5584
5585
5586 if test "x$TAR" = x; then
5587 if test "xtar" = x; then
5588 PROG_NAME=tar
5589 else
5590 PROG_NAME=tar
5591 fi
5592 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5593 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5594 as_fn_error $? "Cannot continue" "$LINENO" 5
5595 fi
5596
5597
5598
5599 for ac_prog in tee
5600 do
5601 # Extract the first word of "$ac_prog", so it can be a program name with args.
5602 set dummy $ac_prog; ac_word=$2
5603 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5604 $as_echo_n "checking for $ac_word... " >&6; }
5605 if ${ac_cv_path_TEE+:} false; then :
5606 $as_echo_n "(cached) " >&6
5607 else
5608 case $TEE in
5609 [\\/]* | ?:[\\/]*)
5610 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
5611 ;;
5612 *)
5613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5614 for as_dir in $PATH
5615 do
5616 IFS=$as_save_IFS
5617 test -z "$as_dir" && as_dir=.
5618 for ac_exec_ext in '' $ac_executable_extensions; do
5619 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5620 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
5621 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5622 break 2
5623 fi
5624 done
5625 done
5626 IFS=$as_save_IFS
5627
5628 ;;
5629 esac
5630 fi
5631 TEE=$ac_cv_path_TEE
5632 if test -n "$TEE"; then
5633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
5634 $as_echo "$TEE" >&6; }
5635 else
5636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5637 $as_echo "no" >&6; }
5638 fi
5639
5640
5641 test -n "$TEE" && break
5642 done
5643
5644
5645 if test "x$TEE" = x; then
5646 if test "xtee" = x; then
5647 PROG_NAME=tee
5648 else
5649 PROG_NAME=tee
5650 fi
5651 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5652 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5653 as_fn_error $? "Cannot continue" "$LINENO" 5
5654 fi
5655
5656
5657
5658 for ac_prog in touch
5659 do
5660 # Extract the first word of "$ac_prog", so it can be a program name with args.
5661 set dummy $ac_prog; ac_word=$2
5662 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5663 $as_echo_n "checking for $ac_word... " >&6; }
5664 if ${ac_cv_path_TOUCH+:} false; then :
5665 $as_echo_n "(cached) " >&6
5666 else
5667 case $TOUCH in
5668 [\\/]* | ?:[\\/]*)
5669 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
5670 ;;
5671 *)
5672 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5673 for as_dir in $PATH
5674 do
5675 IFS=$as_save_IFS
5676 test -z "$as_dir" && as_dir=.
5677 for ac_exec_ext in '' $ac_executable_extensions; do
5678 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5679 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
5680 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5681 break 2
5682 fi
5683 done
5684 done
5685 IFS=$as_save_IFS
5686
5687 ;;
5688 esac
5689 fi
5690 TOUCH=$ac_cv_path_TOUCH
5691 if test -n "$TOUCH"; then
5692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
5693 $as_echo "$TOUCH" >&6; }
5694 else
5695 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5696 $as_echo "no" >&6; }
5697 fi
5698
5699
5700 test -n "$TOUCH" && break
5701 done
5702
5703
5704 if test "x$TOUCH" = x; then
5705 if test "xtouch" = x; then
5706 PROG_NAME=touch
5707 else
5708 PROG_NAME=touch
5709 fi
5710 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5711 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5712 as_fn_error $? "Cannot continue" "$LINENO" 5
5713 fi
5714
5715
5716
5717 for ac_prog in tr
5718 do
5719 # Extract the first word of "$ac_prog", so it can be a program name with args.
5720 set dummy $ac_prog; ac_word=$2
5721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5722 $as_echo_n "checking for $ac_word... " >&6; }
5723 if ${ac_cv_path_TR+:} false; then :
5724 $as_echo_n "(cached) " >&6
5725 else
5726 case $TR in
5727 [\\/]* | ?:[\\/]*)
5728 ac_cv_path_TR="$TR" # Let the user override the test with a path.
5729 ;;
5730 *)
5731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5732 for as_dir in $PATH
5733 do
5734 IFS=$as_save_IFS
5735 test -z "$as_dir" && as_dir=.
5736 for ac_exec_ext in '' $ac_executable_extensions; do
5737 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5738 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
5739 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5740 break 2
5741 fi
5742 done
5743 done
5744 IFS=$as_save_IFS
5745
5746 ;;
5747 esac
5748 fi
5749 TR=$ac_cv_path_TR
5750 if test -n "$TR"; then
5751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
5752 $as_echo "$TR" >&6; }
5753 else
5754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5755 $as_echo "no" >&6; }
5756 fi
5757
5758
5759 test -n "$TR" && break
5760 done
5761
5762
5763 if test "x$TR" = x; then
5764 if test "xtr" = x; then
5765 PROG_NAME=tr
5766 else
5767 PROG_NAME=tr
5768 fi
5769 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5770 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5771 as_fn_error $? "Cannot continue" "$LINENO" 5
5772 fi
5773
5774
5775
5776 for ac_prog in uname
5777 do
5778 # Extract the first word of "$ac_prog", so it can be a program name with args.
5779 set dummy $ac_prog; ac_word=$2
5780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5781 $as_echo_n "checking for $ac_word... " >&6; }
5782 if ${ac_cv_path_UNAME+:} false; then :
5783 $as_echo_n "(cached) " >&6
5784 else
5785 case $UNAME in
5786 [\\/]* | ?:[\\/]*)
5787 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
5788 ;;
5789 *)
5790 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5791 for as_dir in $PATH
5792 do
5793 IFS=$as_save_IFS
5794 test -z "$as_dir" && as_dir=.
5795 for ac_exec_ext in '' $ac_executable_extensions; do
5796 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5797 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
5798 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5799 break 2
5800 fi
5801 done
5802 done
5803 IFS=$as_save_IFS
5804
5805 ;;
5806 esac
5807 fi
5808 UNAME=$ac_cv_path_UNAME
5809 if test -n "$UNAME"; then
5810 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
5811 $as_echo "$UNAME" >&6; }
5812 else
5813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5814 $as_echo "no" >&6; }
5815 fi
5816
5817
5818 test -n "$UNAME" && break
5819 done
5820
5821
5822 if test "x$UNAME" = x; then
5823 if test "xuname" = x; then
5824 PROG_NAME=uname
5825 else
5826 PROG_NAME=uname
5827 fi
5828 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5829 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5830 as_fn_error $? "Cannot continue" "$LINENO" 5
5831 fi
5832
5833
5834
5835 for ac_prog in uniq
5836 do
5837 # Extract the first word of "$ac_prog", so it can be a program name with args.
5838 set dummy $ac_prog; ac_word=$2
5839 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5840 $as_echo_n "checking for $ac_word... " >&6; }
5841 if ${ac_cv_path_UNIQ+:} false; then :
5842 $as_echo_n "(cached) " >&6
5843 else
5844 case $UNIQ in
5845 [\\/]* | ?:[\\/]*)
5846 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
5847 ;;
5848 *)
5849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5850 for as_dir in $PATH
5851 do
5852 IFS=$as_save_IFS
5853 test -z "$as_dir" && as_dir=.
5854 for ac_exec_ext in '' $ac_executable_extensions; do
5855 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5856 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
5857 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5858 break 2
5859 fi
5860 done
5861 done
5862 IFS=$as_save_IFS
5863
5864 ;;
5865 esac
5866 fi
5867 UNIQ=$ac_cv_path_UNIQ
5868 if test -n "$UNIQ"; then
5869 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
5870 $as_echo "$UNIQ" >&6; }
5871 else
5872 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5873 $as_echo "no" >&6; }
5874 fi
5875
5876
5877 test -n "$UNIQ" && break
5878 done
5879
5880
5881 if test "x$UNIQ" = x; then
5882 if test "xuniq" = x; then
5883 PROG_NAME=uniq
5884 else
5885 PROG_NAME=uniq
5886 fi
5887 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5888 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5889 as_fn_error $? "Cannot continue" "$LINENO" 5
5890 fi
5891
5892
5893
5894 for ac_prog in wc
5895 do
5896 # Extract the first word of "$ac_prog", so it can be a program name with args.
5897 set dummy $ac_prog; ac_word=$2
5898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5899 $as_echo_n "checking for $ac_word... " >&6; }
5900 if ${ac_cv_path_WC+:} false; then :
5901 $as_echo_n "(cached) " >&6
5902 else
5903 case $WC in
5904 [\\/]* | ?:[\\/]*)
5905 ac_cv_path_WC="$WC" # Let the user override the test with a path.
5906 ;;
5907 *)
5908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5909 for as_dir in $PATH
5910 do
5911 IFS=$as_save_IFS
5912 test -z "$as_dir" && as_dir=.
5913 for ac_exec_ext in '' $ac_executable_extensions; do
5914 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5915 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
5916 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5917 break 2
5918 fi
5919 done
5920 done
5921 IFS=$as_save_IFS
5922
5923 ;;
5924 esac
5925 fi
5926 WC=$ac_cv_path_WC
5927 if test -n "$WC"; then
5928 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
5929 $as_echo "$WC" >&6; }
5930 else
5931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5932 $as_echo "no" >&6; }
5933 fi
5934
5935
5936 test -n "$WC" && break
5937 done
5938
5939
5940 if test "x$WC" = x; then
5941 if test "xwc" = x; then
5942 PROG_NAME=wc
5943 else
5944 PROG_NAME=wc
5945 fi
5946 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
5947 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
5948 as_fn_error $? "Cannot continue" "$LINENO" 5
5949 fi
5950
5951
5952
5953 for ac_prog in which
5954 do
5955 # Extract the first word of "$ac_prog", so it can be a program name with args.
5956 set dummy $ac_prog; ac_word=$2
5957 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5958 $as_echo_n "checking for $ac_word... " >&6; }
5959 if ${ac_cv_path_WHICH+:} false; then :
5960 $as_echo_n "(cached) " >&6
5961 else
5962 case $WHICH in
5963 [\\/]* | ?:[\\/]*)
5964 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
5965 ;;
5966 *)
5967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5968 for as_dir in $PATH
5969 do
5970 IFS=$as_save_IFS
5971 test -z "$as_dir" && as_dir=.
5972 for ac_exec_ext in '' $ac_executable_extensions; do
5973 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5974 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
5975 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5976 break 2
5977 fi
5978 done
5979 done
5980 IFS=$as_save_IFS
5981
5982 ;;
5983 esac
5984 fi
5985 WHICH=$ac_cv_path_WHICH
5986 if test -n "$WHICH"; then
5987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
5988 $as_echo "$WHICH" >&6; }
5989 else
5990 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5991 $as_echo "no" >&6; }
5992 fi
5993
5994
5995 test -n "$WHICH" && break
5996 done
5997
5998
5999 if test "x$WHICH" = x; then
6000 if test "xwhich" = x; then
6001 PROG_NAME=which
6002 else
6003 PROG_NAME=which
6004 fi
6005 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6006 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6007 as_fn_error $? "Cannot continue" "$LINENO" 5
6008 fi
6009
6010
6011
6012 for ac_prog in xargs
6013 do
6014 # Extract the first word of "$ac_prog", so it can be a program name with args.
6015 set dummy $ac_prog; ac_word=$2
6016 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6017 $as_echo_n "checking for $ac_word... " >&6; }
6018 if ${ac_cv_path_XARGS+:} false; then :
6019 $as_echo_n "(cached) " >&6
6020 else
6021 case $XARGS in
6022 [\\/]* | ?:[\\/]*)
6023 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
6024 ;;
6025 *)
6026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6027 for as_dir in $PATH
6028 do
6029 IFS=$as_save_IFS
6030 test -z "$as_dir" && as_dir=.
6031 for ac_exec_ext in '' $ac_executable_extensions; do
6032 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6033 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
6034 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6035 break 2
6036 fi
6037 done
6038 done
6039 IFS=$as_save_IFS
6040
6041 ;;
6042 esac
6043 fi
6044 XARGS=$ac_cv_path_XARGS
6045 if test -n "$XARGS"; then
6046 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
6047 $as_echo "$XARGS" >&6; }
6048 else
6049 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6050 $as_echo "no" >&6; }
6051 fi
6052
6053
6054 test -n "$XARGS" && break
6055 done
6056
6057
6058 if test "x$XARGS" = x; then
6059 if test "xxargs" = x; then
6060 PROG_NAME=xargs
6061 else
6062 PROG_NAME=xargs
6063 fi
6064 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6065 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6066 as_fn_error $? "Cannot continue" "$LINENO" 5
6067 fi
6068
6069
6070
6071 # Then required tools that require some special treatment.
6072 for ac_prog in gawk mawk nawk awk
6073 do
6074 # Extract the first word of "$ac_prog", so it can be a program name with args.
6075 set dummy $ac_prog; ac_word=$2
6076 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6077 $as_echo_n "checking for $ac_word... " >&6; }
6078 if ${ac_cv_prog_AWK+:} false; then :
6079 $as_echo_n "(cached) " >&6
6080 else
6081 if test -n "$AWK"; then
6082 ac_cv_prog_AWK="$AWK" # Let the user override the test.
6083 else
6084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6085 for as_dir in $PATH
6086 do
6087 IFS=$as_save_IFS
6088 test -z "$as_dir" && as_dir=.
6089 for ac_exec_ext in '' $ac_executable_extensions; do
6090 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6091 ac_cv_prog_AWK="$ac_prog"
6092 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6093 break 2
6094 fi
6095 done
6096 done
6097 IFS=$as_save_IFS
6098
6099 fi
6100 fi
6101 AWK=$ac_cv_prog_AWK
6102 if test -n "$AWK"; then
6103 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
6104 $as_echo "$AWK" >&6; }
6105 else
6106 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6107 $as_echo "no" >&6; }
6108 fi
6109
6110
6111 test -n "$AWK" && break
6112 done
6113
6114
6115 if test "x$AWK" = x; then
6116 if test "x" = x; then
6117 PROG_NAME=awk
6118 else
6119 PROG_NAME=
6120 fi
6121 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6122 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6123 as_fn_error $? "Cannot continue" "$LINENO" 5
6124 fi
6125
6126 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
6127 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
6128 if ${ac_cv_path_GREP+:} false; then :
6129 $as_echo_n "(cached) " >&6
6130 else
6131 if test -z "$GREP"; then
6132 ac_path_GREP_found=false
6133 # Loop through the user's path and test for each of PROGNAME-LIST
6134 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6135 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
6136 do
6137 IFS=$as_save_IFS
6138 test -z "$as_dir" && as_dir=.
6139 for ac_prog in grep ggrep; do
6140 for ac_exec_ext in '' $ac_executable_extensions; do
6141 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
6142 as_fn_executable_p "$ac_path_GREP" || continue
6143 # Check for GNU ac_path_GREP and select it if it is found.
6144 # Check for GNU $ac_path_GREP
6145 case `"$ac_path_GREP" --version 2>&1` in
6146 *GNU*)
6147 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
6148 *)
6149 ac_count=0
6150 $as_echo_n 0123456789 >"conftest.in"
6151 while :
6152 do
6153 cat "conftest.in" "conftest.in" >"conftest.tmp"
6154 mv "conftest.tmp" "conftest.in"
6155 cp "conftest.in" "conftest.nl"
6156 $as_echo 'GREP' >> "conftest.nl"
6157 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
6158 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
6159 as_fn_arith $ac_count + 1 && ac_count=$as_val
6160 if test $ac_count -gt ${ac_path_GREP_max-0}; then
6161 # Best one so far, save it but keep looking for a better one
6162 ac_cv_path_GREP="$ac_path_GREP"
6163 ac_path_GREP_max=$ac_count
6164 fi
6165 # 10*(2^10) chars as input seems more than enough
6166 test $ac_count -gt 10 && break
6167 done
6168 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
6169 esac
6170
6171 $ac_path_GREP_found && break 3
6172 done
6173 done
6174 done
6175 IFS=$as_save_IFS
6176 if test -z "$ac_cv_path_GREP"; then
6177 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6178 fi
6179 else
6180 ac_cv_path_GREP=$GREP
6181 fi
6182
6183 fi
6184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
6185 $as_echo "$ac_cv_path_GREP" >&6; }
6186 GREP="$ac_cv_path_GREP"
6187
6188
6189
6190 if test "x$GREP" = x; then
6191 if test "x" = x; then
6192 PROG_NAME=grep
6193 else
6194 PROG_NAME=
6195 fi
6196 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6197 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6198 as_fn_error $? "Cannot continue" "$LINENO" 5
6199 fi
6200
6201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
6202 $as_echo_n "checking for egrep... " >&6; }
6203 if ${ac_cv_path_EGREP+:} false; then :
6204 $as_echo_n "(cached) " >&6
6205 else
6206 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
6207 then ac_cv_path_EGREP="$GREP -E"
6208 else
6209 if test -z "$EGREP"; then
6210 ac_path_EGREP_found=false
6211 # Loop through the user's path and test for each of PROGNAME-LIST
6212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6213 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
6214 do
6215 IFS=$as_save_IFS
6216 test -z "$as_dir" && as_dir=.
6217 for ac_prog in egrep; do
6218 for ac_exec_ext in '' $ac_executable_extensions; do
6219 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
6220 as_fn_executable_p "$ac_path_EGREP" || continue
6221 # Check for GNU ac_path_EGREP and select it if it is found.
6222 # Check for GNU $ac_path_EGREP
6223 case `"$ac_path_EGREP" --version 2>&1` in
6224 *GNU*)
6225 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
6226 *)
6227 ac_count=0
6228 $as_echo_n 0123456789 >"conftest.in"
6229 while :
6230 do
6231 cat "conftest.in" "conftest.in" >"conftest.tmp"
6232 mv "conftest.tmp" "conftest.in"
6233 cp "conftest.in" "conftest.nl"
6234 $as_echo 'EGREP' >> "conftest.nl"
6235 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
6236 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
6237 as_fn_arith $ac_count + 1 && ac_count=$as_val
6238 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
6239 # Best one so far, save it but keep looking for a better one
6240 ac_cv_path_EGREP="$ac_path_EGREP"
6241 ac_path_EGREP_max=$ac_count
6242 fi
6243 # 10*(2^10) chars as input seems more than enough
6244 test $ac_count -gt 10 && break
6245 done
6246 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
6247 esac
6248
6249 $ac_path_EGREP_found && break 3
6250 done
6251 done
6252 done
6253 IFS=$as_save_IFS
6254 if test -z "$ac_cv_path_EGREP"; then
6255 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6256 fi
6257 else
6258 ac_cv_path_EGREP=$EGREP
6259 fi
6260
6261 fi
6262 fi
6263 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
6264 $as_echo "$ac_cv_path_EGREP" >&6; }
6265 EGREP="$ac_cv_path_EGREP"
6266
6267
6268
6269 if test "x$EGREP" = x; then
6270 if test "x" = x; then
6271 PROG_NAME=egrep
6272 else
6273 PROG_NAME=
6274 fi
6275 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6276 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6277 as_fn_error $? "Cannot continue" "$LINENO" 5
6278 fi
6279
6280 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
6281 $as_echo_n "checking for fgrep... " >&6; }
6282 if ${ac_cv_path_FGREP+:} false; then :
6283 $as_echo_n "(cached) " >&6
6284 else
6285 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
6286 then ac_cv_path_FGREP="$GREP -F"
6287 else
6288 if test -z "$FGREP"; then
6289 ac_path_FGREP_found=false
6290 # Loop through the user's path and test for each of PROGNAME-LIST
6291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6292 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
6293 do
6294 IFS=$as_save_IFS
6295 test -z "$as_dir" && as_dir=.
6296 for ac_prog in fgrep; do
6297 for ac_exec_ext in '' $ac_executable_extensions; do
6298 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
6299 as_fn_executable_p "$ac_path_FGREP" || continue
6300 # Check for GNU ac_path_FGREP and select it if it is found.
6301 # Check for GNU $ac_path_FGREP
6302 case `"$ac_path_FGREP" --version 2>&1` in
6303 *GNU*)
6304 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
6305 *)
6306 ac_count=0
6307 $as_echo_n 0123456789 >"conftest.in"
6308 while :
6309 do
6310 cat "conftest.in" "conftest.in" >"conftest.tmp"
6311 mv "conftest.tmp" "conftest.in"
6312 cp "conftest.in" "conftest.nl"
6313 $as_echo 'FGREP' >> "conftest.nl"
6314 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
6315 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
6316 as_fn_arith $ac_count + 1 && ac_count=$as_val
6317 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
6318 # Best one so far, save it but keep looking for a better one
6319 ac_cv_path_FGREP="$ac_path_FGREP"
6320 ac_path_FGREP_max=$ac_count
6321 fi
6322 # 10*(2^10) chars as input seems more than enough
6323 test $ac_count -gt 10 && break
6324 done
6325 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
6326 esac
6327
6328 $ac_path_FGREP_found && break 3
6329 done
6330 done
6331 done
6332 IFS=$as_save_IFS
6333 if test -z "$ac_cv_path_FGREP"; then
6334 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6335 fi
6336 else
6337 ac_cv_path_FGREP=$FGREP
6338 fi
6339
6340 fi
6341 fi
6342 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
6343 $as_echo "$ac_cv_path_FGREP" >&6; }
6344 FGREP="$ac_cv_path_FGREP"
6345
6346
6347
6348 if test "x$FGREP" = x; then
6349 if test "x" = x; then
6350 PROG_NAME=fgrep
6351 else
6352 PROG_NAME=
6353 fi
6354 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6355 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6356 as_fn_error $? "Cannot continue" "$LINENO" 5
6357 fi
6358
6359 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
6360 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
6361 if ${ac_cv_path_SED+:} false; then :
6362 $as_echo_n "(cached) " >&6
6363 else
6364 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
6365 for ac_i in 1 2 3 4 5 6 7; do
6366 ac_script="$ac_script$as_nl$ac_script"
6367 done
6368 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
6369 { ac_script=; unset ac_script;}
6370 if test -z "$SED"; then
6371 ac_path_SED_found=false
6372 # Loop through the user's path and test for each of PROGNAME-LIST
6373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6374 for as_dir in $PATH
6375 do
6376 IFS=$as_save_IFS
6377 test -z "$as_dir" && as_dir=.
6378 for ac_prog in sed gsed; do
6379 for ac_exec_ext in '' $ac_executable_extensions; do
6380 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
6381 as_fn_executable_p "$ac_path_SED" || continue
6382 # Check for GNU ac_path_SED and select it if it is found.
6383 # Check for GNU $ac_path_SED
6384 case `"$ac_path_SED" --version 2>&1` in
6385 *GNU*)
6386 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
6387 *)
6388 ac_count=0
6389 $as_echo_n 0123456789 >"conftest.in"
6390 while :
6391 do
6392 cat "conftest.in" "conftest.in" >"conftest.tmp"
6393 mv "conftest.tmp" "conftest.in"
6394 cp "conftest.in" "conftest.nl"
6395 $as_echo '' >> "conftest.nl"
6396 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
6397 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
6398 as_fn_arith $ac_count + 1 && ac_count=$as_val
6399 if test $ac_count -gt ${ac_path_SED_max-0}; then
6400 # Best one so far, save it but keep looking for a better one
6401 ac_cv_path_SED="$ac_path_SED"
6402 ac_path_SED_max=$ac_count
6403 fi
6404 # 10*(2^10) chars as input seems more than enough
6405 test $ac_count -gt 10 && break
6406 done
6407 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
6408 esac
6409
6410 $ac_path_SED_found && break 3
6411 done
6412 done
6413 done
6414 IFS=$as_save_IFS
6415 if test -z "$ac_cv_path_SED"; then
6416 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
6417 fi
6418 else
6419 ac_cv_path_SED=$SED
6420 fi
6421
6422 fi
6423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
6424 $as_echo "$ac_cv_path_SED" >&6; }
6425 SED="$ac_cv_path_SED"
6426 rm -f conftest.sed
6427
6428
6429 if test "x$SED" = x; then
6430 if test "x" = x; then
6431 PROG_NAME=sed
6432 else
6433 PROG_NAME=
6434 fi
6435 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6436 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6437 as_fn_error $? "Cannot continue" "$LINENO" 5
6438 fi
6439
6440
6441 for ac_prog in nawk gawk awk
6442 do
6443 # Extract the first word of "$ac_prog", so it can be a program name with args.
6444 set dummy $ac_prog; ac_word=$2
6445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6446 $as_echo_n "checking for $ac_word... " >&6; }
6447 if ${ac_cv_path_NAWK+:} false; then :
6448 $as_echo_n "(cached) " >&6
6449 else
6450 case $NAWK in
6451 [\\/]* | ?:[\\/]*)
6452 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
6453 ;;
6454 *)
6455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6456 for as_dir in $PATH
6457 do
6458 IFS=$as_save_IFS
6459 test -z "$as_dir" && as_dir=.
6460 for ac_exec_ext in '' $ac_executable_extensions; do
6461 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6462 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
6463 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6464 break 2
6465 fi
6466 done
6467 done
6468 IFS=$as_save_IFS
6469
6470 ;;
6471 esac
6472 fi
6473 NAWK=$ac_cv_path_NAWK
6474 if test -n "$NAWK"; then
6475 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
6476 $as_echo "$NAWK" >&6; }
6477 else
6478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6479 $as_echo "no" >&6; }
6480 fi
6481
6482
6483 test -n "$NAWK" && break
6484 done
6485
6486
6487 if test "x$NAWK" = x; then
6488 if test "x" = x; then
6489 PROG_NAME=nawk
6490 else
6491 PROG_NAME=
6492 fi
6493 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
6494 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
6495 as_fn_error $? "Cannot continue" "$LINENO" 5
6496 fi
6497
6498
6499 # Always force rm.
6500 RM="$RM -f"
6501
6502 # pwd behaves differently on various platforms and some don't support the -L flag.
6503 # Always use the bash builtin pwd to get uniform behavior.
6504 THEPWDCMD=pwd
6505
6506 # These are not required on all platforms
6507 # Extract the first word of "cygpath", so it can be a program name with args.
6508 set dummy cygpath; ac_word=$2
6509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6510 $as_echo_n "checking for $ac_word... " >&6; }
6511 if ${ac_cv_path_CYGPATH+:} false; then :
6512 $as_echo_n "(cached) " >&6
6513 else
6514 case $CYGPATH in
6515 [\\/]* | ?:[\\/]*)
6516 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
6517 ;;
6518 *)
6519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6520 for as_dir in $PATH
6521 do
6522 IFS=$as_save_IFS
6523 test -z "$as_dir" && as_dir=.
6524 for ac_exec_ext in '' $ac_executable_extensions; do
6525 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6526 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
6527 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6528 break 2
6529 fi
6530 done
6531 done
6532 IFS=$as_save_IFS
6533
6534 ;;
6535 esac
6536 fi
6537 CYGPATH=$ac_cv_path_CYGPATH
6538 if test -n "$CYGPATH"; then
6539 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
6540 $as_echo "$CYGPATH" >&6; }
6541 else
6542 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6543 $as_echo "no" >&6; }
6544 fi
6545
6546
6547 # Extract the first word of "readlink", so it can be a program name with args.
6548 set dummy readlink; ac_word=$2
6549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6550 $as_echo_n "checking for $ac_word... " >&6; }
6551 if ${ac_cv_path_READLINK+:} false; then :
6552 $as_echo_n "(cached) " >&6
6553 else
6554 case $READLINK in
6555 [\\/]* | ?:[\\/]*)
6556 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
6557 ;;
6558 *)
6559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6560 for as_dir in $PATH
6561 do
6562 IFS=$as_save_IFS
6563 test -z "$as_dir" && as_dir=.
6564 for ac_exec_ext in '' $ac_executable_extensions; do
6565 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6566 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
6567 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6568 break 2
6569 fi
6570 done
6571 done
6572 IFS=$as_save_IFS
6573
6574 ;;
6575 esac
6576 fi
6577 READLINK=$ac_cv_path_READLINK
6578 if test -n "$READLINK"; then
6579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
6580 $as_echo "$READLINK" >&6; }
6581 else
6582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6583 $as_echo "no" >&6; }
6584 fi
6585
6586
6587 # Extract the first word of "df", so it can be a program name with args.
6588 set dummy df; ac_word=$2
6589 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6590 $as_echo_n "checking for $ac_word... " >&6; }
6591 if ${ac_cv_path_DF+:} false; then :
6592 $as_echo_n "(cached) " >&6
6593 else
6594 case $DF in
6595 [\\/]* | ?:[\\/]*)
6596 ac_cv_path_DF="$DF" # Let the user override the test with a path.
6597 ;;
6598 *)
6599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6600 for as_dir in $PATH
6601 do
6602 IFS=$as_save_IFS
6603 test -z "$as_dir" && as_dir=.
6604 for ac_exec_ext in '' $ac_executable_extensions; do
6605 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6606 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
6607 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6608 break 2
6609 fi
6610 done
6611 done
6612 IFS=$as_save_IFS
6613
6614 ;;
6615 esac
6616 fi
6617 DF=$ac_cv_path_DF
6618 if test -n "$DF"; then
6619 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
6620 $as_echo "$DF" >&6; }
6621 else
6622 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6623 $as_echo "no" >&6; }
6624 fi
6625
6626
6627 # Extract the first word of "SetFile", so it can be a program name with args.
6628 set dummy SetFile; ac_word=$2
6629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6630 $as_echo_n "checking for $ac_word... " >&6; }
6631 if ${ac_cv_path_SETFILE+:} false; then :
6632 $as_echo_n "(cached) " >&6
6633 else
6634 case $SETFILE in
6635 [\\/]* | ?:[\\/]*)
6636 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
6637 ;;
6638 *)
6639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6640 for as_dir in $PATH
6641 do
6642 IFS=$as_save_IFS
6643 test -z "$as_dir" && as_dir=.
6644 for ac_exec_ext in '' $ac_executable_extensions; do
6645 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6646 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
6647 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6648 break 2
6649 fi
6650 done
6651 done
6652 IFS=$as_save_IFS
6653
6654 ;;
6655 esac
6656 fi
6657 SETFILE=$ac_cv_path_SETFILE
6658 if test -n "$SETFILE"; then
6659 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
6660 $as_echo "$SETFILE" >&6; }
6661 else
6662 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6663 $as_echo "no" >&6; }
6664 fi
6665
6666
6667
6668
6669 # Now we can determine OpenJDK build and target platforms. This is required to
6670 # have early on.
6671 # Make sure we can run config.sub.
6672 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
6673 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
6674
6675 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
6676 $as_echo_n "checking build system type... " >&6; }
6677 if ${ac_cv_build+:} false; then :
6678 $as_echo_n "(cached) " >&6
6679 else
6680 ac_build_alias=$build_alias
6681 test "x$ac_build_alias" = x &&
6682 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
6683 test "x$ac_build_alias" = x &&
6684 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
6685 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
6686 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
6687
6688 fi
6689 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
6690 $as_echo "$ac_cv_build" >&6; }
6691 case $ac_cv_build in
6692 *-*-*) ;;
6693 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
6694 esac
6695 build=$ac_cv_build
6696 ac_save_IFS=$IFS; IFS='-'
6697 set x $ac_cv_build
6698 shift
6699 build_cpu=$1
6700 build_vendor=$2
6701 shift; shift
6702 # Remember, the first character of IFS is used to create $*,
6703 # except with old shells:
6704 build_os=$*
6705 IFS=$ac_save_IFS
6706 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
6707
6708
6709 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
6710 $as_echo_n "checking host system type... " >&6; }
6711 if ${ac_cv_host+:} false; then :
6712 $as_echo_n "(cached) " >&6
6713 else
6714 if test "x$host_alias" = x; then
6715 ac_cv_host=$ac_cv_build
6716 else
6717 ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
6718 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
6719 fi
6720
6721 fi
6722 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
6723 $as_echo "$ac_cv_host" >&6; }
6724 case $ac_cv_host in
6725 *-*-*) ;;
6726 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
6727 esac
6728 host=$ac_cv_host
6729 ac_save_IFS=$IFS; IFS='-'
6730 set x $ac_cv_host
6731 shift
6732 host_cpu=$1
6733 host_vendor=$2
6734 shift; shift
6735 # Remember, the first character of IFS is used to create $*,
6736 # except with old shells:
6737 host_os=$*
6738 IFS=$ac_save_IFS
6739 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
6740
6741
6742 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
6743 $as_echo_n "checking target system type... " >&6; }
6744 if ${ac_cv_target+:} false; then :
6745 $as_echo_n "(cached) " >&6
6746 else
6747 if test "x$target_alias" = x; then
6748 ac_cv_target=$ac_cv_host
6749 else
6750 ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
6751 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
6752 fi
6753
6754 fi
6755 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
6756 $as_echo "$ac_cv_target" >&6; }
6757 case $ac_cv_target in
6758 *-*-*) ;;
6759 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
6760 esac
6761 target=$ac_cv_target
6762 ac_save_IFS=$IFS; IFS='-'
6763 set x $ac_cv_target
6764 shift
6765 target_cpu=$1
6766 target_vendor=$2
6767 shift; shift
6768 # Remember, the first character of IFS is used to create $*,
6769 # except with old shells:
6770 target_os=$*
6771 IFS=$ac_save_IFS
6772 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
6773
6774
6775 # The aliases save the names the user supplied, while $host etc.
6776 # will get canonicalized.
6777 test -n "$target_alias" &&
6778 test "$program_prefix$program_suffix$program_transform_name" = \
6779 NONENONEs,x,x, &&
6780 program_prefix=${target_alias}-
6781
6782 # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
6783 # is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
6784 # product you're building. The target of this build is called "host". Since this is confusing to most people, we
6785 # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
6786 # to use the configure naming style.
6787
6788
6789
6790
6791
6792 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
6793 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
6794 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
6795 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
6796 OPENJDK_TARGET_AUTOCONF_NAME="$host"
6797 OPENJDK_BUILD_AUTOCONF_NAME="$build"
6798
6799
6800
6801 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
6802
6803 case "$build_os" in
6804 *linux*)
6805 VAR_OS=linux
6806 VAR_OS_API=posix
6807 VAR_OS_ENV=linux
6808 ;;
6809 *solaris*)
6810 VAR_OS=solaris
6811 VAR_OS_API=posix
6812 VAR_OS_ENV=solaris
6813 ;;
6814 *darwin*)
6815 VAR_OS=macosx
6816 VAR_OS_API=posix
6817 VAR_OS_ENV=macosx
6818 ;;
6819 *bsd*)
6820 VAR_OS=bsd
6821 VAR_OS_API=posix
6822 VAR_OS_ENV=bsd
6823 ;;
6824 *cygwin*)
6825 VAR_OS=windows
6826 VAR_OS_API=winapi
6827 VAR_OS_ENV=windows.cygwin
6828 ;;
6829 *mingw*)
6830 VAR_OS=windows
6831 VAR_OS_API=winapi
6832 VAR_OS_ENV=windows.msys
6833 ;;
6834 *aix*)
6835 VAR_OS=aix
6836 VAR_OS_API=posix
6837 VAR_OS_ENV=aix
6838 ;;
6839 *)
6840 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
6841 ;;
6842 esac
6843
6844
6845 # First argument is the cpu name from the trip/quad
6846 case "$build_cpu" in
6847 x86_64)
6848 VAR_CPU=x86_64
6849 VAR_CPU_ARCH=x86
6850 VAR_CPU_BITS=64
6851 VAR_CPU_ENDIAN=little
6852 ;;
6853 i?86)
6854 VAR_CPU=x86
6855 VAR_CPU_ARCH=x86
6856 VAR_CPU_BITS=32
6857 VAR_CPU_ENDIAN=little
6858 ;;
6859 arm*)
6860 VAR_CPU=arm
6861 VAR_CPU_ARCH=arm
6862 VAR_CPU_BITS=32
6863 VAR_CPU_ENDIAN=little
6864 ;;
6865 aarch64)
6866 VAR_CPU=aarch64
6867 VAR_CPU_ARCH=aarch64
6868 VAR_CPU_BITS=64
6869 VAR_CPU_ENDIAN=little
6870 ;;
6871 powerpc)
6872 VAR_CPU=ppc
6873 VAR_CPU_ARCH=ppc
6874 VAR_CPU_BITS=32
6875 VAR_CPU_ENDIAN=big
6876 ;;
6877 powerpc64)
6878 VAR_CPU=ppc64
6879 VAR_CPU_ARCH=ppc
6880 VAR_CPU_BITS=64
6881 VAR_CPU_ENDIAN=big
6882 ;;
6883 powerpc64le)
6884 VAR_CPU=ppc64
6885 VAR_CPU_ARCH=ppc
6886 VAR_CPU_BITS=64
6887 VAR_CPU_ENDIAN=little
6888 ;;
6889 s390)
6890 VAR_CPU=s390
6891 VAR_CPU_ARCH=s390
6892 VAR_CPU_BITS=32
6893 VAR_CPU_ENDIAN=big
6894 ;;
6895 s390x)
6896 VAR_CPU=s390x
6897 VAR_CPU_ARCH=s390
6898 VAR_CPU_BITS=64
6899 VAR_CPU_ENDIAN=big
6900 ;;
6901 sparc)
6902 VAR_CPU=sparc
6903 VAR_CPU_ARCH=sparc
6904 VAR_CPU_BITS=32
6905 VAR_CPU_ENDIAN=big
6906 ;;
6907 sparcv9|sparc64)
6908 VAR_CPU=sparcv9
6909 VAR_CPU_ARCH=sparc
6910 VAR_CPU_BITS=64
6911 VAR_CPU_ENDIAN=big
6912 ;;
6913 *)
6914 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
6915 ;;
6916 esac
6917
6918 # ..and setup our own variables. (Do this explicitely to facilitate searching)
6919 OPENJDK_BUILD_OS="$VAR_OS"
6920 OPENJDK_BUILD_OS_API="$VAR_OS_API"
6921 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
6922 OPENJDK_BUILD_CPU="$VAR_CPU"
6923 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
6924 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
6925 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
6926
6927
6928
6929
6930
6931
6932
6933 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
6934 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
6935 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
6936 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
6937
6938 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
6939
6940 case "$host_os" in
6941 *linux*)
6942 VAR_OS=linux
6943 VAR_OS_API=posix
6944 VAR_OS_ENV=linux
6945 ;;
6946 *solaris*)
6947 VAR_OS=solaris
6948 VAR_OS_API=posix
6949 VAR_OS_ENV=solaris
6950 ;;
6951 *darwin*)
6952 VAR_OS=macosx
6953 VAR_OS_API=posix
6954 VAR_OS_ENV=macosx
6955 ;;
6956 *bsd*)
6957 VAR_OS=bsd
6958 VAR_OS_API=posix
6959 VAR_OS_ENV=bsd
6960 ;;
6961 *cygwin*)
6962 VAR_OS=windows
6963 VAR_OS_API=winapi
6964 VAR_OS_ENV=windows.cygwin
6965 ;;
6966 *mingw*)
6967 VAR_OS=windows
6968 VAR_OS_API=winapi
6969 VAR_OS_ENV=windows.msys
6970 ;;
6971 *aix*)
6972 VAR_OS=aix
6973 VAR_OS_API=posix
6974 VAR_OS_ENV=aix
6975 ;;
6976 *)
6977 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
6978 ;;
6979 esac
6980
6981
6982 # First argument is the cpu name from the trip/quad
6983 case "$host_cpu" in
6984 x86_64)
6985 VAR_CPU=x86_64
6986 VAR_CPU_ARCH=x86
6987 VAR_CPU_BITS=64
6988 VAR_CPU_ENDIAN=little
6989 ;;
6990 i?86)
6991 VAR_CPU=x86
6992 VAR_CPU_ARCH=x86
6993 VAR_CPU_BITS=32
6994 VAR_CPU_ENDIAN=little
6995 ;;
6996 arm*)
6997 VAR_CPU=arm
6998 VAR_CPU_ARCH=arm
6999 VAR_CPU_BITS=32
7000 VAR_CPU_ENDIAN=little
7001 ;;
7002 aarch64)
7003 VAR_CPU=aarch64
7004 VAR_CPU_ARCH=aarch64
7005 VAR_CPU_BITS=64
7006 VAR_CPU_ENDIAN=little
7007 ;;
7008 powerpc)
7009 VAR_CPU=ppc
7010 VAR_CPU_ARCH=ppc
7011 VAR_CPU_BITS=32
7012 VAR_CPU_ENDIAN=big
7013 ;;
7014 powerpc64)
7015 VAR_CPU=ppc64
7016 VAR_CPU_ARCH=ppc
7017 VAR_CPU_BITS=64
7018 VAR_CPU_ENDIAN=big
7019 ;;
7020 powerpc64le)
7021 VAR_CPU=ppc64
7022 VAR_CPU_ARCH=ppc
7023 VAR_CPU_BITS=64
7024 VAR_CPU_ENDIAN=little
7025 ;;
7026 s390)
7027 VAR_CPU=s390
7028 VAR_CPU_ARCH=s390
7029 VAR_CPU_BITS=32
7030 VAR_CPU_ENDIAN=big
7031 ;;
7032 s390x)
7033 VAR_CPU=s390x
7034 VAR_CPU_ARCH=s390
7035 VAR_CPU_BITS=64
7036 VAR_CPU_ENDIAN=big
7037 ;;
7038 sparc)
7039 VAR_CPU=sparc
7040 VAR_CPU_ARCH=sparc
7041 VAR_CPU_BITS=32
7042 VAR_CPU_ENDIAN=big
7043 ;;
7044 sparcv9|sparc64)
7045 VAR_CPU=sparcv9
7046 VAR_CPU_ARCH=sparc
7047 VAR_CPU_BITS=64
7048 VAR_CPU_ENDIAN=big
7049 ;;
7050 *)
7051 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
7052 ;;
7053 esac
7054
7055 # ... and setup our own variables. (Do this explicitely to facilitate searching)
7056 OPENJDK_TARGET_OS="$VAR_OS"
7057 OPENJDK_TARGET_OS_API="$VAR_OS_API"
7058 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
7059 OPENJDK_TARGET_CPU="$VAR_CPU"
7060 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
7061 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
7062 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
7063
7064
7065
7066
7067
7068
7069
7070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
7071 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
7072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
7073 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
7074
7075
7076
7077 # Check whether --with-target-bits was given.
7078 if test "${with_target_bits+set}" = set; then :
7079 withval=$with_target_bits;
7080 fi
7081
7082
7083 # We have three types of compiles:
7084 # native == normal compilation, target system == build system
7085 # cross == traditional cross compilation, target system != build system; special toolchain needed
7086 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
7087 #
7088 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
7089 # We're doing a proper cross-compilation
7090 COMPILE_TYPE="cross"
7091 else
7092 COMPILE_TYPE="native"
7093 fi
7094
7095 if test "x$with_target_bits" != x; then
7096 if test "x$COMPILE_TYPE" = "xcross"; then
7097 as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
7098 fi
7099
7100 if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
7101 # A reduced build is requested
7102 COMPILE_TYPE="reduced"
7103 OPENJDK_TARGET_CPU_BITS=32
7104 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
7105 OPENJDK_TARGET_CPU=x86
7106 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
7107 OPENJDK_TARGET_CPU=sparc
7108 else
7109 as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
7110 fi
7111 elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
7112 as_fn_error $? "It is not possible to use --with-target-bits=64 on a 32 bit system. Use proper cross-compilation instead." "$LINENO" 5
7113 elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
7114 { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
7115 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
7116 else
7117 as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
7118 fi
7119 fi
7120
7121
7122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
7123 $as_echo_n "checking compilation type... " >&6; }
7124 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
7125 $as_echo "$COMPILE_TYPE" >&6; }
7126
7127
7128 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
7129 REQUIRED_OS_NAME=SunOS
7130 REQUIRED_OS_VERSION=5.10
7131 fi
7132 if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
7133 REQUIRED_OS_NAME=Linux
7134 REQUIRED_OS_VERSION=2.6
7135 fi
7136 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
7137 REQUIRED_OS_NAME=Windows
7138 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
7139 REQUIRED_OS_VERSION=5.2
7140 else
7141 REQUIRED_OS_VERSION=5.1
7142 fi
7143 fi
7144 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
7145 REQUIRED_OS_NAME=Darwin
7146 REQUIRED_OS_VERSION=11.2
7147 fi
7148
7149
7150
7151
7152
7153 # Also store the legacy naming of the cpu.
7154 # Ie i586 and amd64 instead of x86 and x86_64
7155 OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
7156 if test "x$OPENJDK_TARGET_CPU" = xx86; then
7157 OPENJDK_TARGET_CPU_LEGACY="i586"
7158 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
7159 # On all platforms except MacOSX replace x86_64 with amd64.
7160 OPENJDK_TARGET_CPU_LEGACY="amd64"
7161 fi
7162
7163
7164 # And the second legacy naming of the cpu.
7165 # Ie i386 and amd64 instead of x86 and x86_64.
7166 OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
7167 if test "x$OPENJDK_TARGET_CPU" = xx86; then
7168 OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
7169 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
7170 OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
7171 fi
7172
7173
7174 # This is the name of the cpu (but using i386 and amd64 instead of
7175 # x86 and x86_64, respectively), preceeded by a /, to be used when
7176 # locating libraries. On macosx, it's empty, though.
7177 OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
7178 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
7179 OPENJDK_TARGET_CPU_LIBDIR=""
7180 fi
7181
7182
7183 # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
7184 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
7185 # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
7186 OPENJDK_TARGET_CPU_ISADIR=""
7187 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
7188 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
7189 OPENJDK_TARGET_CPU_ISADIR="/amd64"
7190 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
7191 OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
7192 fi
7193 fi
7194
7195
7196 # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
7197 OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
7198 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
7199 # On linux only, we replace x86 with i386.
7200 OPENJDK_TARGET_CPU_OSARCH="i386"
7201 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
7202 # On all platforms except macosx, we replace x86_64 with amd64.
7203 OPENJDK_TARGET_CPU_OSARCH="amd64"
7204 fi
7205
7206
7207 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
7208 if test "x$OPENJDK_TARGET_CPU" = xx86; then
7209 OPENJDK_TARGET_CPU_JLI="i386"
7210 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
7211 # On all platforms except macosx, we replace x86_64 with amd64.
7212 OPENJDK_TARGET_CPU_JLI="amd64"
7213 fi
7214 # Now setup the -D flags for building libjli.
7215 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
7216 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
7217 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
7218 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
7219 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
7220 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
7221 fi
7222 fi
7223
7224
7225 # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
7226 if test "x$OPENJDK_TARGET_OS_API" = xposix; then
7227 OPENJDK_TARGET_OS_API_DIR="solaris"
7228 fi
7229 if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
7230 OPENJDK_TARGET_OS_API_DIR="windows"
7231 fi
7232
7233
7234 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
7235 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
7236 else
7237 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
7238 fi
7239
7240
7241 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
7242 A_LP64="LP64:="
7243 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
7244 # unpack200.exe
7245 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
7246 ADD_LP64="-D_LP64=1"
7247 fi
7248 fi
7249 LP64=$A_LP64
7250
7251
7252 if test "x$COMPILE_TYPE" = "xcross"; then
7253 # FIXME: ... or should this include reduced builds..?
7254 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
7255 else
7256 DEFINE_CROSS_COMPILE_ARCH=""
7257 fi
7258
7259
7260 # ZERO_ARCHDEF is used to enable architecture-specific code
7261 case "${OPENJDK_TARGET_CPU}" in
7262 ppc) ZERO_ARCHDEF=PPC32 ;;
7263 ppc64) ZERO_ARCHDEF=PPC64 ;;
7264 s390*) ZERO_ARCHDEF=S390 ;;
7265 sparc*) ZERO_ARCHDEF=SPARC ;;
7266 x86_64*) ZERO_ARCHDEF=AMD64 ;;
7267 x86) ZERO_ARCHDEF=IA32 ;;
7268 *) ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
7269 esac
7270
7271
7272
7273
7274 # Continue setting up basic stuff. Most remaining code require fundamental tools.
7275
7276 # Locate the directory of this script.
7277 SCRIPT="$0"
7278 AUTOCONF_DIR=`cd \`$DIRNAME $SCRIPT\`; $THEPWDCMD -L`
7279
7280 # Where is the source? It is located two levels above the configure script.
7281 CURDIR="$PWD"
7282 cd "$AUTOCONF_DIR/../.."
7283 SRC_ROOT="`$THEPWDCMD -L`"
7284
7285 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
7286 PATH_SEP=";"
7287
7288 SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
7289 if test $SRC_ROOT_LENGTH -gt 100; then
7290 as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
7291 fi
7292
7293 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7294 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
7295 $as_echo_n "checking cygwin release... " >&6; }
7296 CYGWIN_VERSION=`$UNAME -r`
7297 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
7298 $as_echo "$CYGWIN_VERSION" >&6; }
7299 WINDOWS_ENV_VENDOR='cygwin'
7300 WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
7301
7302 CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
7303 if test "x$CYGWIN_VERSION_OLD" != x; then
7304 { $as_echo "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
7305 $as_echo "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
7306 as_fn_error $? "Cannot continue" "$LINENO" 5
7307 fi
7308 if test "x$CYGPATH" = x; then
7309 as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
7310 fi
7311 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
7312 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
7313 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
7314 cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
7315 # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
7316 CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
7317 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
7318 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
7319 WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
7320 test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
7321 if test "x$test_cygdrive_prefix" = x; then
7322 as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
7323 fi
7324 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
7326 $as_echo_n "checking msys release... " >&6; }
7327 MSYS_VERSION=`$UNAME -r`
7328 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
7329 $as_echo "$MSYS_VERSION" >&6; }
7330
7331 WINDOWS_ENV_VENDOR='msys'
7332 WINDOWS_ENV_VERSION="$MSYS_VERSION"
7333
7334 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
7335 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
7336 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
7337 MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
7338
7339 windows_path="$MSYS_ROOT_PATH"
7340 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7341 unix_path=`$CYGPATH -u "$windows_path"`
7342 MSYS_ROOT_PATH="$unix_path"
7343 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7344 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
7345 MSYS_ROOT_PATH="$unix_path"
7346 fi
7347
7348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
7349 $as_echo "$MSYS_ROOT_PATH" >&6; }
7350 WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
7351 else
7352 as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
7353 fi
7354
7355 # Test if windows or unix (cygwin/msys) find is first in path.
7356 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
7357 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
7358 FIND_BINARY_OUTPUT=`find --version 2>&1`
7359 if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
7360 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
7361 $as_echo "unix style" >&6; }
7362 elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
7363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
7364 $as_echo "Windows" >&6; }
7365 { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
7366 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
7367 { $as_echo "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
7368 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
7369 as_fn_error $? "Cannot continue" "$LINENO" 5
7370 else
7371 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
7372 $as_echo "unknown" >&6; }
7373 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
7374 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
7375 fi
7376
7377 else
7378 PATH_SEP=":"
7379 fi
7380
7381
7382
7383 cd "$CURDIR"
7384
7385
7386 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7387
7388 # Input might be given as Windows format, start by converting to
7389 # unix format.
7390 path="$SRC_ROOT"
7391 new_path=`$CYGPATH -u "$path"`
7392
7393 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
7394 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
7395 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
7396 # "foo.exe" is OK but "foo" is an error.
7397 #
7398 # This test is therefore slightly more accurate than "test -f" to check for file precense.
7399 # It is also a way to make sure we got the proper file name for the real test later on.
7400 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
7401 if test "x$test_shortpath" = x; then
7402 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&5
7403 $as_echo "$as_me: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&6;}
7404 as_fn_error $? "Cannot locate the the path of SRC_ROOT" "$LINENO" 5
7405 fi
7406
7407 # Call helper function which possibly converts this using DOS-style short mode.
7408 # If so, the updated path is stored in $new_path.
7409
7410 input_path="$new_path"
7411 # Check if we need to convert this using DOS-style short mode. If the path
7412 # contains just simple characters, use it. Otherwise (spaces, weird characters),
7413 # take no chances and rewrite it.
7414 # Note: m4 eats our [], so we need to use [ and ] instead.
7415 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
7416 if test "x$has_forbidden_chars" != x; then
7417 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
7418 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
7419 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
7420 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
7421 # Going to short mode and back again did indeed matter. Since short mode is
7422 # case insensitive, let's make it lowercase to improve readability.
7423 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
7424 # Now convert it back to Unix-stile (cygpath)
7425 input_path=`$CYGPATH -u "$shortmode_path"`
7426 new_path="$input_path"
7427 fi
7428 fi
7429
7430 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
7431 if test "x$test_cygdrive_prefix" = x; then
7432 # As a simple fix, exclude /usr/bin since it's not a real path.
7433 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
7434 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
7435 # a path prefixed by /cygdrive for fixpath to work.
7436 new_path="$CYGWIN_ROOT_PATH$input_path"
7437 fi
7438 fi
7439
7440
7441 if test "x$path" != "x$new_path"; then
7442 SRC_ROOT="$new_path"
7443 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting SRC_ROOT to \"$new_path\"" >&5
7444 $as_echo "$as_me: Rewriting SRC_ROOT to \"$new_path\"" >&6;}
7445 fi
7446
7447 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7448
7449 path="$SRC_ROOT"
7450 has_colon=`$ECHO $path | $GREP ^.:`
7451 new_path="$path"
7452 if test "x$has_colon" = x; then
7453 # Not in mixed or Windows style, start by that.
7454 new_path=`cmd //c echo $path`
7455 fi
7456
7457
7458 input_path="$new_path"
7459 # Check if we need to convert this using DOS-style short mode. If the path
7460 # contains just simple characters, use it. Otherwise (spaces, weird characters),
7461 # take no chances and rewrite it.
7462 # Note: m4 eats our [], so we need to use [ and ] instead.
7463 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
7464 if test "x$has_forbidden_chars" != x; then
7465 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
7466 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
7467 fi
7468
7469
7470 windows_path="$new_path"
7471 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7472 unix_path=`$CYGPATH -u "$windows_path"`
7473 new_path="$unix_path"
7474 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7475 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
7476 new_path="$unix_path"
7477 fi
7478
7479 if test "x$path" != "x$new_path"; then
7480 SRC_ROOT="$new_path"
7481 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting SRC_ROOT to \"$new_path\"" >&5
7482 $as_echo "$as_me: Rewriting SRC_ROOT to \"$new_path\"" >&6;}
7483 fi
7484
7485 # Save the first 10 bytes of this path to the storage, so fixpath can work.
7486 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
7487
7488 else
7489 # We're on a posix platform. Hooray! :)
7490 path="$SRC_ROOT"
7491 has_space=`$ECHO "$path" | $GREP " "`
7492 if test "x$has_space" != x; then
7493 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&5
7494 $as_echo "$as_me: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&6;}
7495 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
7496 fi
7497
7498 # Use eval to expand a potential ~
7499 eval path="$path"
7500 if test ! -f "$path" && test ! -d "$path"; then
7501 as_fn_error $? "The path of SRC_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
7502 fi
7503
7504 SRC_ROOT="`cd "$path"; $THEPWDCMD -L`"
7505 fi
7506
7507
7508 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7509
7510 # Input might be given as Windows format, start by converting to
7511 # unix format.
7512 path="$CURDIR"
7513 new_path=`$CYGPATH -u "$path"`
7514
7515 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
7516 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
7517 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
7518 # "foo.exe" is OK but "foo" is an error.
7519 #
7520 # This test is therefore slightly more accurate than "test -f" to check for file precense.
7521 # It is also a way to make sure we got the proper file name for the real test later on.
7522 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
7523 if test "x$test_shortpath" = x; then
7524 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
7525 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
7526 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
7527 fi
7528
7529 # Call helper function which possibly converts this using DOS-style short mode.
7530 # If so, the updated path is stored in $new_path.
7531
7532 input_path="$new_path"
7533 # Check if we need to convert this using DOS-style short mode. If the path
7534 # contains just simple characters, use it. Otherwise (spaces, weird characters),
7535 # take no chances and rewrite it.
7536 # Note: m4 eats our [], so we need to use [ and ] instead.
7537 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
7538 if test "x$has_forbidden_chars" != x; then
7539 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
7540 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
7541 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
7542 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
7543 # Going to short mode and back again did indeed matter. Since short mode is
7544 # case insensitive, let's make it lowercase to improve readability.
7545 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
7546 # Now convert it back to Unix-stile (cygpath)
7547 input_path=`$CYGPATH -u "$shortmode_path"`
7548 new_path="$input_path"
7549 fi
7550 fi
7551
7552 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
7553 if test "x$test_cygdrive_prefix" = x; then
7554 # As a simple fix, exclude /usr/bin since it's not a real path.
7555 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
7556 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
7557 # a path prefixed by /cygdrive for fixpath to work.
7558 new_path="$CYGWIN_ROOT_PATH$input_path"
7559 fi
7560 fi
7561
7562
7563 if test "x$path" != "x$new_path"; then
7564 CURDIR="$new_path"
7565 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
7566 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
7567 fi
7568
7569 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7570
7571 path="$CURDIR"
7572 has_colon=`$ECHO $path | $GREP ^.:`
7573 new_path="$path"
7574 if test "x$has_colon" = x; then
7575 # Not in mixed or Windows style, start by that.
7576 new_path=`cmd //c echo $path`
7577 fi
7578
7579
7580 input_path="$new_path"
7581 # Check if we need to convert this using DOS-style short mode. If the path
7582 # contains just simple characters, use it. Otherwise (spaces, weird characters),
7583 # take no chances and rewrite it.
7584 # Note: m4 eats our [], so we need to use [ and ] instead.
7585 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
7586 if test "x$has_forbidden_chars" != x; then
7587 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
7588 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
7589 fi
7590
7591
7592 windows_path="$new_path"
7593 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7594 unix_path=`$CYGPATH -u "$windows_path"`
7595 new_path="$unix_path"
7596 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7597 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
7598 new_path="$unix_path"
7599 fi
7600
7601 if test "x$path" != "x$new_path"; then
7602 CURDIR="$new_path"
7603 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
7604 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
7605 fi
7606
7607 # Save the first 10 bytes of this path to the storage, so fixpath can work.
7608 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
7609
7610 else
7611 # We're on a posix platform. Hooray! :)
7612 path="$CURDIR"
7613 has_space=`$ECHO "$path" | $GREP " "`
7614 if test "x$has_space" != x; then
7615 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
7616 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
7617 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
7618 fi
7619
7620 # Use eval to expand a potential ~
7621 eval path="$path"
7622 if test ! -f "$path" && test ! -d "$path"; then
7623 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
7624 fi
7625
7626 CURDIR="`cd "$path"; $THEPWDCMD -L`"
7627 fi
7628
7629
7630 if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
7631 # Add extra search paths on solaris for utilities like ar and as etc...
7632 PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
7633 fi
7634
7635 # You can force the sys-root if the sys-root encoded into the cross compiler tools
7636 # is not correct.
7637
7638 # Check whether --with-sys-root was given.
7639 if test "${with_sys_root+set}" = set; then :
7640 withval=$with_sys_root;
7641 fi
7642
7643
7644 if test "x$with_sys_root" != x; then
7645 SYS_ROOT=$with_sys_root
7646 else
7647 SYS_ROOT=/
7648 fi
7649
7650
7651
7652 # Check whether --with-tools-dir was given.
7653 if test "${with_tools_dir+set}" = set; then :
7654 withval=$with_tools_dir; TOOLS_DIR=$with_tools_dir
7655
7656 fi
7657
7658
7659 # Xcode version will be validated later
7660
7661 # Check whether --with-xcode-path was given.
7662 if test "${with_xcode_path+set}" = set; then :
7663 withval=$with_xcode_path; XCODE_PATH=$with_xcode_path
7664
7665 fi
7666
7667
7668
7669 # Check whether --with-devkit was given.
7670 if test "${with_devkit+set}" = set; then :
7671 withval=$with_devkit;
7672 if test "x$with_sys_root" != x; then
7673 as_fn_error $? "Cannot specify both --with-devkit and --with-sys-root at the same time" "$LINENO" 5
7674 fi
7675
7676 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7677
7678 # Input might be given as Windows format, start by converting to
7679 # unix format.
7680 path="$with_devkit"
7681 new_path=`$CYGPATH -u "$path"`
7682
7683 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
7684 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
7685 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
7686 # "foo.exe" is OK but "foo" is an error.
7687 #
7688 # This test is therefore slightly more accurate than "test -f" to check for file precense.
7689 # It is also a way to make sure we got the proper file name for the real test later on.
7690 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
7691 if test "x$test_shortpath" = x; then
7692 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
7693 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
7694 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
7695 fi
7696
7697 # Call helper function which possibly converts this using DOS-style short mode.
7698 # If so, the updated path is stored in $new_path.
7699
7700 input_path="$new_path"
7701 # Check if we need to convert this using DOS-style short mode. If the path
7702 # contains just simple characters, use it. Otherwise (spaces, weird characters),
7703 # take no chances and rewrite it.
7704 # Note: m4 eats our [], so we need to use [ and ] instead.
7705 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
7706 if test "x$has_forbidden_chars" != x; then
7707 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
7708 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
7709 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
7710 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
7711 # Going to short mode and back again did indeed matter. Since short mode is
7712 # case insensitive, let's make it lowercase to improve readability.
7713 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
7714 # Now convert it back to Unix-stile (cygpath)
7715 input_path=`$CYGPATH -u "$shortmode_path"`
7716 new_path="$input_path"
7717 fi
7718 fi
7719
7720 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
7721 if test "x$test_cygdrive_prefix" = x; then
7722 # As a simple fix, exclude /usr/bin since it's not a real path.
7723 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
7724 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
7725 # a path prefixed by /cygdrive for fixpath to work.
7726 new_path="$CYGWIN_ROOT_PATH$input_path"
7727 fi
7728 fi
7729
7730
7731 if test "x$path" != "x$new_path"; then
7732 with_devkit="$new_path"
7733 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
7734 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
7735 fi
7736
7737 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7738
7739 path="$with_devkit"
7740 has_colon=`$ECHO $path | $GREP ^.:`
7741 new_path="$path"
7742 if test "x$has_colon" = x; then
7743 # Not in mixed or Windows style, start by that.
7744 new_path=`cmd //c echo $path`
7745 fi
7746
7747
7748 input_path="$new_path"
7749 # Check if we need to convert this using DOS-style short mode. If the path
7750 # contains just simple characters, use it. Otherwise (spaces, weird characters),
7751 # take no chances and rewrite it.
7752 # Note: m4 eats our [], so we need to use [ and ] instead.
7753 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
7754 if test "x$has_forbidden_chars" != x; then
7755 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
7756 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
7757 fi
7758
7759
7760 windows_path="$new_path"
7761 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
7762 unix_path=`$CYGPATH -u "$windows_path"`
7763 new_path="$unix_path"
7764 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
7765 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
7766 new_path="$unix_path"
7767 fi
7768
7769 if test "x$path" != "x$new_path"; then
7770 with_devkit="$new_path"
7771 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
7772 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
7773 fi
7774
7775 # Save the first 10 bytes of this path to the storage, so fixpath can work.
7776 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
7777
7778 else
7779 # We're on a posix platform. Hooray! :)
7780 path="$with_devkit"
7781 has_space=`$ECHO "$path" | $GREP " "`
7782 if test "x$has_space" != x; then
7783 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
7784 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
7785 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
7786 fi
7787
7788 # Use eval to expand a potential ~
7789 eval path="$path"
7790 if test ! -f "$path" && test ! -d "$path"; then
7791 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
7792 fi
7793
7794 with_devkit="`cd "$path"; $THEPWDCMD -L`"
7795 fi
7796
7797
7798 if test "x$TOOLS_DIR" = x; then
7799 TOOLS_DIR="$with_devkit/bin"
7800 else
7801 TOOLS_DIR="$TOOLS_DIR:$with_devkit/bin"
7802 fi
7803
7804 if test -d "$with_devkit/$host_alias/libc"; then
7805 SYS_ROOT=$with_devkit/$host_alias/libc
7806 elif test -d "$with_devkit/$host/sys-root"; then
7807 SYS_ROOT=$with_devkit/$host/sys-root
7808 fi
7809
7810 fi
7811
7812
7813
7814 # Setup default logging of stdout and stderr to build.log in the output root.
7815 BUILD_LOG='$(OUTPUT_ROOT)/build.log'
7816 BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
7817 BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
7818
7819
7820
7821
7822
7823 # Check if it's a pure open build or if custom sources are to be used.
7824
7825 # Check whether --enable-openjdk-only was given.
7826 if test "${enable_openjdk_only+set}" = set; then :
7827 enableval=$enable_openjdk_only;
7828 else
7829 enable_openjdk_only="no"
7830 fi
7831
7832
7833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
7834 $as_echo_n "checking for presence of closed sources... " >&6; }
7835 if test -d "$SRC_ROOT/jdk/src/closed"; then
7836 CLOSED_SOURCE_PRESENT=yes
7837 else
7838 CLOSED_SOURCE_PRESENT=no
7839 fi
7840 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
7841 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
7842
7843 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
7844 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
7845 SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
7846 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
7847 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
7848
7849 if test "x$CLOSED_SOURCE_PRESENT" = xno; then
7850 OPENJDK=true
7851 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
7852 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
7853 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
7854 fi
7855 else
7856 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
7857 OPENJDK=true
7858 else
7859 OPENJDK=false
7860 fi
7861 fi
7862
7863 if test "x$OPENJDK" = "xtrue"; then
7864 SET_OPENJDK="OPENJDK=true"
7865 fi
7866
7867
7868
7869
7870 # These are needed to be able to create a configuration name (and thus the output directory)
7871
7872 ###############################################################################
7873 #
7874 # Check which variant of the JDK that we want to build.
7875 # Currently we have:
7876 # normal: standard edition
7877 # but the custom make system may add other variants
7878 #
7879 # Effectively the JDK variant gives a name to a specific set of
7880 # modules to compile into the JDK. In the future, these modules
7881 # might even be Jigsaw modules.
7882 #
7883 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
7884 $as_echo_n "checking which variant of the JDK to build... " >&6; }
7885
7886 # Check whether --with-jdk-variant was given.
7887 if test "${with_jdk_variant+set}" = set; then :
7888 withval=$with_jdk_variant;
7889 fi
7890
7891
7892 if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
7893 JDK_VARIANT="normal"
7894 else
7895 as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
7896 fi
7897
7898
7899
7900 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
7901 $as_echo "$JDK_VARIANT" >&6; }
7902
7903
7904 ###############################################################################
7905 #
7906 # Check which interpreter of the JVM we want to build.
7907 # Currently we have:
7908 # template: Template interpreter (the default)
7909 # cpp : C++ interpreter
7910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
7911 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
7912
7913 # Check whether --with-jvm-interpreter was given.
7914 if test "${with_jvm_interpreter+set}" = set; then :
7915 withval=$with_jvm_interpreter;
7916 fi
7917
7918
7919 if test "x$with_jvm_interpreter" = x; then
7920 with_jvm_interpreter="template"
7921 fi
7922
7923 JVM_INTERPRETER="$with_jvm_interpreter"
7924
7925 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
7926 as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
7927 fi
7928
7929
7930
7931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
7932 $as_echo "$with_jvm_interpreter" >&6; }
7933
7934
7935
7936 ###############################################################################
7937 #
7938 # Check which variants of the JVM that we want to build.
7939 # Currently we have:
7940 # server: normal interpreter and a tiered C1/C2 compiler
7941 # client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
7942 # minimal1: reduced form of client with optional VM services and features stripped out
7943 # kernel: kernel footprint JVM that passes the TCK without major performance problems,
7944 # ie normal interpreter and C1, only the serial GC, kernel jvmti etc
7945 # zero: no machine code interpreter, no compiler
7946 # zeroshark: zero interpreter and shark/llvm compiler backend
7947 # core: interpreter only, no compiler (only works on some platforms)
7948 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
7949 $as_echo_n "checking which variants of the JVM to build... " >&6; }
7950
7951 # Check whether --with-jvm-variants was given.
7952 if test "${with_jvm_variants+set}" = set; then :
7953 withval=$with_jvm_variants;
7954 fi
7955
7956
7957 if test "x$with_jvm_variants" = x; then
7958 with_jvm_variants="server"
7959 fi
7960
7961 JVM_VARIANTS=",$with_jvm_variants,"
7962 TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/minimal1,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//' -e 's/core,//'`
7963
7964 if test "x$TEST_VARIANTS" != "x,"; then
7965 as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
7966 fi
7967 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
7968 $as_echo "$with_jvm_variants" >&6; }
7969
7970 JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
7971 JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
7972 JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
7973 JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
7974 JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
7975 JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
7976 JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
7977
7978 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
7979 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
7980 as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
7981 fi
7982 fi
7983 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
7984 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
7985 as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
7986 fi
7987 fi
7988 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
7989 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
7990 as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
7991 fi
7992 fi
7993
7994 # Replace the commas with AND for use in the build directory name.
7995 ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
7996 COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/minimal1,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/' -e 's/core,/1/'`
7997 if test "x$COUNT_VARIANTS" != "x,1"; then
7998 BUILDING_MULTIPLE_JVM_VARIANTS=yes
7999 else
8000 BUILDING_MULTIPLE_JVM_VARIANTS=no
8001 fi
8002
8003
8004
8005
8006
8007
8008
8009
8010
8011
8012 INCLUDE_SA=true
8013 if test "x$JVM_VARIANT_ZERO" = xtrue ; then
8014 INCLUDE_SA=false
8015 fi
8016 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
8017 INCLUDE_SA=false
8018 fi
8019 if test "x$VAR_CPU" = xppc64 ; then
8020 INCLUDE_SA=false
8021 fi
8022 if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
8023 INCLUDE_SA=false
8024 fi
8025
8026
8027 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
8028 MACOSX_UNIVERSAL="false"
8029 fi
8030
8031
8032
8033
8034 ###############################################################################
8035 #
8036 # Set the debug level
8037 # release: no debug information, all optimizations, no asserts.
8038 # fastdebug: debug information (-g), all optimizations, all asserts
8039 # slowdebug: debug information (-g), no optimizations, all asserts
8040 #
8041 DEBUG_LEVEL="release"
8042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
8043 $as_echo_n "checking which debug level to use... " >&6; }
8044 # Check whether --enable-debug was given.
8045 if test "${enable_debug+set}" = set; then :
8046 enableval=$enable_debug;
8047 ENABLE_DEBUG="${enableval}"
8048 DEBUG_LEVEL="fastdebug"
8049
8050 else
8051 ENABLE_DEBUG="no"
8052 fi
8053
8054
8055
8056 # Check whether --with-debug-level was given.
8057 if test "${with_debug_level+set}" = set; then :
8058 withval=$with_debug_level;
8059 DEBUG_LEVEL="${withval}"
8060 if test "x$ENABLE_DEBUG" = xyes; then
8061 as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
8062 fi
8063
8064 fi
8065
8066 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
8067 $as_echo "$DEBUG_LEVEL" >&6; }
8068
8069 if test "x$DEBUG_LEVEL" != xrelease && \
8070 test "x$DEBUG_LEVEL" != xfastdebug && \
8071 test "x$DEBUG_LEVEL" != xslowdebug; then
8072 as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
8073 fi
8074
8075
8076 ###############################################################################
8077 #
8078 # Setup legacy vars/targets and new vars to deal with different debug levels.
8079 #
8080
8081 case $DEBUG_LEVEL in
8082 release )
8083 VARIANT="OPT"
8084 FASTDEBUG="false"
8085 DEBUG_CLASSFILES="false"
8086 BUILD_VARIANT_RELEASE=""
8087 HOTSPOT_DEBUG_LEVEL="product"
8088 HOTSPOT_EXPORT="product"
8089 ;;
8090 fastdebug )
8091 VARIANT="DBG"
8092 FASTDEBUG="true"
8093 DEBUG_CLASSFILES="true"
8094 BUILD_VARIANT_RELEASE="-fastdebug"
8095 HOTSPOT_DEBUG_LEVEL="fastdebug"
8096 HOTSPOT_EXPORT="fastdebug"
8097 ;;
8098 slowdebug )
8099 VARIANT="DBG"
8100 FASTDEBUG="false"
8101 DEBUG_CLASSFILES="true"
8102 BUILD_VARIANT_RELEASE="-debug"
8103 HOTSPOT_DEBUG_LEVEL="jvmg"
8104 HOTSPOT_EXPORT="debug"
8105 ;;
8106 esac
8107
8108 #####
8109 # Generate the legacy makefile targets for hotspot.
8110 # The hotspot api for selecting the build artifacts, really, needs to be improved.
8111 # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
8112 # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
8113 # But until then ...
8114 HOTSPOT_TARGET=""
8115
8116 if test "x$JVM_VARIANT_SERVER" = xtrue; then
8117 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
8118 fi
8119
8120 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
8121 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
8122 fi
8123
8124 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
8125 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
8126 fi
8127
8128 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
8129 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
8130 fi
8131
8132 if test "x$JVM_VARIANT_ZERO" = xtrue; then
8133 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
8134 fi
8135
8136 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
8137 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
8138 fi
8139
8140 if test "x$JVM_VARIANT_CORE" = xtrue; then
8141 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
8142 fi
8143
8144 HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
8145
8146 # On Macosx universal binaries are produced, but they only contain
8147 # 64 bit intel. This invalidates control of which jvms are built
8148 # from configure, but only server is valid anyway. Fix this
8149 # when hotspot makefiles are rewritten.
8150 if test "x$MACOSX_UNIVERSAL" = xtrue; then
8151 HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
8152 fi
8153
8154 #####
8155
8156
8157
8158
8159
8160
8161
8162
8163 # With basic setup done, call the custom early hook.
8164
8165
8166 # To properly create a configuration name, we need to have the OpenJDK target
8167 # and options (variants and debug level) parsed.
8168
8169
8170
8171 # Check whether --with-conf-name was given.
8172 if test "${with_conf_name+set}" = set; then :
8173 withval=$with_conf_name; CONF_NAME=${with_conf_name}
8174 fi
8175
8176
8177 # Test from where we are running configure, in or outside of src root.
8178 if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
8179 || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
8180 || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
8181 # We are running configure from the src root.
8182 # Create a default ./build/target-variant-debuglevel output root.
8183 if test "x${CONF_NAME}" = x; then
8184 CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
8185 fi
8186 OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
8187 $MKDIR -p "$OUTPUT_ROOT"
8188 if test ! -d "$OUTPUT_ROOT"; then
8189 as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
8190 fi
8191 else
8192 # We are running configure from outside of the src dir.
8193 # Then use the current directory as output dir!
8194 # If configuration is situated in normal build directory, just use the build
8195 # directory name as configuration name, otherwise use the complete path.
8196 if test "x${CONF_NAME}" = x; then
8197 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
8198 fi
8199 OUTPUT_ROOT="$CURDIR"
8200
8201 # WARNING: This might be a bad thing to do. You need to be sure you want to
8202 # have a configuration in this directory. Do some sanity checks!
8203
8204 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
8205 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
8206 # other files
8207 files_present=`$LS $OUTPUT_ROOT`
8208 # Configure has already touched config.log and confdefs.h in the current dir when this check
8209 # is performed.
8210 filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
8211 | $TR -d '\n'`
8212 if test "x$filtered_files" != x; then
8213 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
8214 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
8215 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
8216 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
8217 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
8218 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
8219 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
8220 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
8221 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
8222 $as_echo "$as_me: seriously mess up just about everything." >&6;}
8223 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
8224 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
8225 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
8226 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
8227 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
8228 fi
8229 fi
8230 fi
8231 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
8232 $as_echo_n "checking what configuration name to use... " >&6; }
8233 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
8234 $as_echo "$CONF_NAME" >&6; }
8235
8236
8237 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
8238
8239 # Input might be given as Windows format, start by converting to
8240 # unix format.
8241 path="$OUTPUT_ROOT"
8242 new_path=`$CYGPATH -u "$path"`
8243
8244 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
8245 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
8246 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
8247 # "foo.exe" is OK but "foo" is an error.
8248 #
8249 # This test is therefore slightly more accurate than "test -f" to check for file precense.
8250 # It is also a way to make sure we got the proper file name for the real test later on.
8251 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
8252 if test "x$test_shortpath" = x; then
8253 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
8254 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
8255 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
8256 fi
8257
8258 # Call helper function which possibly converts this using DOS-style short mode.
8259 # If so, the updated path is stored in $new_path.
8260
8261 input_path="$new_path"
8262 # Check if we need to convert this using DOS-style short mode. If the path
8263 # contains just simple characters, use it. Otherwise (spaces, weird characters),
8264 # take no chances and rewrite it.
8265 # Note: m4 eats our [], so we need to use [ and ] instead.
8266 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
8267 if test "x$has_forbidden_chars" != x; then
8268 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
8269 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
8270 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
8271 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
8272 # Going to short mode and back again did indeed matter. Since short mode is
8273 # case insensitive, let's make it lowercase to improve readability.
8274 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
8275 # Now convert it back to Unix-stile (cygpath)
8276 input_path=`$CYGPATH -u "$shortmode_path"`
8277 new_path="$input_path"
8278 fi
8279 fi
8280
8281 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
8282 if test "x$test_cygdrive_prefix" = x; then
8283 # As a simple fix, exclude /usr/bin since it's not a real path.
8284 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
8285 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
8286 # a path prefixed by /cygdrive for fixpath to work.
8287 new_path="$CYGWIN_ROOT_PATH$input_path"
8288 fi
8289 fi
8290
8291
8292 if test "x$path" != "x$new_path"; then
8293 OUTPUT_ROOT="$new_path"
8294 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
8295 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
8296 fi
8297
8298 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
8299
8300 path="$OUTPUT_ROOT"
8301 has_colon=`$ECHO $path | $GREP ^.:`
8302 new_path="$path"
8303 if test "x$has_colon" = x; then
8304 # Not in mixed or Windows style, start by that.
8305 new_path=`cmd //c echo $path`
8306 fi
8307
8308
8309 input_path="$new_path"
8310 # Check if we need to convert this using DOS-style short mode. If the path
8311 # contains just simple characters, use it. Otherwise (spaces, weird characters),
8312 # take no chances and rewrite it.
8313 # Note: m4 eats our [], so we need to use [ and ] instead.
8314 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
8315 if test "x$has_forbidden_chars" != x; then
8316 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
8317 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
8318 fi
8319
8320
8321 windows_path="$new_path"
8322 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
8323 unix_path=`$CYGPATH -u "$windows_path"`
8324 new_path="$unix_path"
8325 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
8326 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
8327 new_path="$unix_path"
8328 fi
8329
8330 if test "x$path" != "x$new_path"; then
8331 OUTPUT_ROOT="$new_path"
8332 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
8333 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
8334 fi
8335
8336 # Save the first 10 bytes of this path to the storage, so fixpath can work.
8337 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
8338
8339 else
8340 # We're on a posix platform. Hooray! :)
8341 path="$OUTPUT_ROOT"
8342 has_space=`$ECHO "$path" | $GREP " "`
8343 if test "x$has_space" != x; then
8344 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
8345 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
8346 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
8347 fi
8348
8349 # Use eval to expand a potential ~
8350 eval path="$path"
8351 if test ! -f "$path" && test ! -d "$path"; then
8352 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
8353 fi
8354
8355 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
8356 fi
8357
8358
8359 SPEC=$OUTPUT_ROOT/spec.gmk
8360
8361 CONF_NAME=$CONF_NAME
8362
8363 OUTPUT_ROOT=$OUTPUT_ROOT
8364
8365
8366 # Most of the probed defines are put into config.h
8367 ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in"
8368
8369 # The spec.gmk file contains all variables for the make system.
8370 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
8371
8372 # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
8373 ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
8374
8375 # The bootcycle-spec.gmk file contains support for boot cycle builds.
8376 ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
8377
8378 # The compare.sh is used to compare the build output to other builds.
8379 ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
8380
8381 # Spec.sh is currently used by compare-objects.sh
8382 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in"
8383
8384 # The generated Makefile knows where the spec.gmk is and where the source is.
8385 # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
8386 # which will look for generated configurations
8387 ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
8388
8389
8390 # Save the arguments given to us
8391 echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments
8392
8393
8394 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
8395
8396 for ac_prog in apt-get yum port pkgutil pkgadd
8397 do
8398 # Extract the first word of "$ac_prog", so it can be a program name with args.
8399 set dummy $ac_prog; ac_word=$2
8400 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8401 $as_echo_n "checking for $ac_word... " >&6; }
8402 if ${ac_cv_prog_PKGHANDLER+:} false; then :
8403 $as_echo_n "(cached) " >&6
8404 else
8405 if test -n "$PKGHANDLER"; then
8406 ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
8407 else
8408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8409 for as_dir in $PATH
8410 do
8411 IFS=$as_save_IFS
8412 test -z "$as_dir" && as_dir=.
8413 for ac_exec_ext in '' $ac_executable_extensions; do
8414 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8415 ac_cv_prog_PKGHANDLER="$ac_prog"
8416 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8417 break 2
8418 fi
8419 done
8420 done
8421 IFS=$as_save_IFS
8422
8423 fi
8424 fi
8425 PKGHANDLER=$ac_cv_prog_PKGHANDLER
8426 if test -n "$PKGHANDLER"; then
8427 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
8428 $as_echo "$PKGHANDLER" >&6; }
8429 else
8430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8431 $as_echo "no" >&6; }
8432 fi
8433
8434
8435 test -n "$PKGHANDLER" && break
8436 done
8437
8438
8439
8440 # Setup tools that requires more complex handling, or that is not needed by the configure script.
8441
8442
8443 # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
8444 if test "x$MAKE" != x; then
8445 # User has supplied a make, test it.
8446 if test ! -f "$MAKE"; then
8447 as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
8448 fi
8449
8450 MAKE_CANDIDATE=""$MAKE""
8451 DESCRIPTION="user supplied MAKE=$MAKE"
8452 if test "x$MAKE_CANDIDATE" != x; then
8453 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
8454 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
8455 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
8456 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
8457 if test "x$IS_GNU_MAKE" = x; then
8458 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
8459 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
8460 else
8461 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
8462 if test "x$IS_MODERN_MAKE" = x; then
8463 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
8464 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
8465 else
8466 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
8467 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
8468 MAKE_EXPECTED_ENV='cygwin'
8469 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
8470 MAKE_EXPECTED_ENV='msys'
8471 else
8737
8738 # Now join together the path and the arguments once again
8739 if test "x$arguments" != xEOL; then
8740 new_complete="$new_path ${arguments% *}"
8741 else
8742 new_complete="$new_path"
8743 fi
8744
8745 if test "x$complete" != "x$new_complete"; then
8746 FOUND_MAKE="$new_complete"
8747 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
8748 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
8749 fi
8750
8751 fi
8752 fi
8753 fi
8754 fi
8755
8756 if test "x$FOUND_MAKE" = x; then
8757 as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
8758 fi
8759 else
8760 # Try our hardest to locate a correct version of GNU make
8761 for ac_prog in gmake
8762 do
8763 # Extract the first word of "$ac_prog", so it can be a program name with args.
8764 set dummy $ac_prog; ac_word=$2
8765 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8766 $as_echo_n "checking for $ac_word... " >&6; }
8767 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
8768 $as_echo_n "(cached) " >&6
8769 else
8770 case $CHECK_GMAKE in
8771 [\\/]* | ?:[\\/]*)
8772 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
8773 ;;
8774 *)
8775 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8776 for as_dir in $PATH
8777 do
8778 IFS=$as_save_IFS
8779 test -z "$as_dir" && as_dir=.
8780 for ac_exec_ext in '' $ac_executable_extensions; do
8781 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8782 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
8783 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8784 break 2
8785 fi
8786 done
8787 done
8788 IFS=$as_save_IFS
8789
8790 ;;
8791 esac
8792 fi
8793 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
8794 if test -n "$CHECK_GMAKE"; then
8795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
8796 $as_echo "$CHECK_GMAKE" >&6; }
8797 else
8798 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8799 $as_echo "no" >&6; }
8800 fi
8801
8802
8803 test -n "$CHECK_GMAKE" && break
8804 done
8805
8806
8807 MAKE_CANDIDATE=""$CHECK_GMAKE""
8808 DESCRIPTION="gmake in PATH"
8809 if test "x$MAKE_CANDIDATE" != x; then
8810 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
8811 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
8812 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
8813 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
8814 if test "x$IS_GNU_MAKE" = x; then
8815 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
8816 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
8817 else
8818 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
8819 if test "x$IS_MODERN_MAKE" = x; then
8820 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
8821 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
8822 else
8823 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
8824 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
8825 MAKE_EXPECTED_ENV='cygwin'
8826 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
8827 MAKE_EXPECTED_ENV='msys'
8828 else
9093 fi
9094
9095 # Now join together the path and the arguments once again
9096 if test "x$arguments" != xEOL; then
9097 new_complete="$new_path ${arguments% *}"
9098 else
9099 new_complete="$new_path"
9100 fi
9101
9102 if test "x$complete" != "x$new_complete"; then
9103 FOUND_MAKE="$new_complete"
9104 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
9105 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
9106 fi
9107
9108 fi
9109 fi
9110 fi
9111 fi
9112
9113
9114 if test "x$FOUND_MAKE" = x; then
9115 for ac_prog in make
9116 do
9117 # Extract the first word of "$ac_prog", so it can be a program name with args.
9118 set dummy $ac_prog; ac_word=$2
9119 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9120 $as_echo_n "checking for $ac_word... " >&6; }
9121 if ${ac_cv_path_CHECK_MAKE+:} false; then :
9122 $as_echo_n "(cached) " >&6
9123 else
9124 case $CHECK_MAKE in
9125 [\\/]* | ?:[\\/]*)
9126 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
9127 ;;
9128 *)
9129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9130 for as_dir in $PATH
9131 do
9132 IFS=$as_save_IFS
9133 test -z "$as_dir" && as_dir=.
9134 for ac_exec_ext in '' $ac_executable_extensions; do
9135 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9136 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
9137 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9138 break 2
9139 fi
9140 done
9141 done
9142 IFS=$as_save_IFS
9143
9144 ;;
9145 esac
9146 fi
9147 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
9148 if test -n "$CHECK_MAKE"; then
9149 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
9150 $as_echo "$CHECK_MAKE" >&6; }
9151 else
9152 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9153 $as_echo "no" >&6; }
9154 fi
9155
9156
9157 test -n "$CHECK_MAKE" && break
9158 done
9159
9160
9161 MAKE_CANDIDATE=""$CHECK_MAKE""
9162 DESCRIPTION="make in PATH"
9163 if test "x$MAKE_CANDIDATE" != x; then
9164 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
9165 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
9166 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
9167 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
9168 if test "x$IS_GNU_MAKE" = x; then
9169 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
9170 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
9171 else
9172 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
9173 if test "x$IS_MODERN_MAKE" = x; then
9174 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
9175 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
9176 else
9177 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
9178 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9179 MAKE_EXPECTED_ENV='cygwin'
9180 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9181 MAKE_EXPECTED_ENV='msys'
9182 else
9183 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
9184 fi
9185 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
9186 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
9187 else
9188 # Not relevant for non-Windows
9189 IS_MAKE_CORRECT_ENV=true
9190 fi
9191 if test "x$IS_MAKE_CORRECT_ENV" = x; then
9192 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
9193 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
9194 else
9195 FOUND_MAKE=$MAKE_CANDIDATE
9196
9197 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9198
9199 # First separate the path from the arguments. This will split at the first
9200 # space.
9201 complete="$FOUND_MAKE"
9202 path="${complete%% *}"
9203 tmp="$complete EOL"
9204 arguments="${tmp#* }"
9205
9206 # Input might be given as Windows format, start by converting to
9207 # unix format.
9208 new_path=`$CYGPATH -u "$path"`
9209
9210 # Now try to locate executable using which
9211 new_path=`$WHICH "$new_path" 2> /dev/null`
9212 # bat and cmd files are not always considered executable in cygwin causing which
9213 # to not find them
9214 if test "x$new_path" = x \
9215 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
9216 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
9217 new_path=`$CYGPATH -u "$path"`
9218 fi
9219 if test "x$new_path" = x; then
9220 # Oops. Which didn't find the executable.
9221 # The splitting of arguments from the executable at a space might have been incorrect,
9222 # since paths with space are more likely in Windows. Give it another try with the whole
9223 # argument.
9224 path="$complete"
9225 arguments="EOL"
9226 new_path=`$CYGPATH -u "$path"`
9227 new_path=`$WHICH "$new_path" 2> /dev/null`
9228 # bat and cmd files are not always considered executable in cygwin causing which
9229 # to not find them
9230 if test "x$new_path" = x \
9231 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
9232 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
9233 new_path=`$CYGPATH -u "$path"`
9234 fi
9235 if test "x$new_path" = x; then
9236 # It's still not found. Now this is an unrecoverable error.
9237 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9238 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9239 has_space=`$ECHO "$complete" | $GREP " "`
9240 if test "x$has_space" != x; then
9241 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
9242 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
9243 fi
9244 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9245 fi
9246 fi
9247
9248 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
9249 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
9250 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
9251 # "foo.exe" is OK but "foo" is an error.
9252 #
9253 # This test is therefore slightly more accurate than "test -f" to check for file presence.
9254 # It is also a way to make sure we got the proper file name for the real test later on.
9255 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
9256 if test "x$test_shortpath" = x; then
9257 # Short path failed, file does not exist as specified.
9258 # Try adding .exe or .cmd
9259 if test -f "${new_path}.exe"; then
9260 input_to_shortpath="${new_path}.exe"
9261 elif test -f "${new_path}.cmd"; then
9262 input_to_shortpath="${new_path}.cmd"
9263 else
9264 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
9265 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
9266 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
9267 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
9268 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9269 fi
9270 else
9271 input_to_shortpath="$new_path"
9272 fi
9273
9274 # Call helper function which possibly converts this using DOS-style short mode.
9275 # If so, the updated path is stored in $new_path.
9276 new_path="$input_to_shortpath"
9277
9278 input_path="$input_to_shortpath"
9279 # Check if we need to convert this using DOS-style short mode. If the path
9280 # contains just simple characters, use it. Otherwise (spaces, weird characters),
9281 # take no chances and rewrite it.
9282 # Note: m4 eats our [], so we need to use [ and ] instead.
9283 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
9284 if test "x$has_forbidden_chars" != x; then
9285 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
9286 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
9287 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
9288 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
9289 # Going to short mode and back again did indeed matter. Since short mode is
9290 # case insensitive, let's make it lowercase to improve readability.
9291 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
9292 # Now convert it back to Unix-stile (cygpath)
9293 input_path=`$CYGPATH -u "$shortmode_path"`
9294 new_path="$input_path"
9295 fi
9296 fi
9297
9298 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
9299 if test "x$test_cygdrive_prefix" = x; then
9300 # As a simple fix, exclude /usr/bin since it's not a real path.
9301 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
9302 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
9303 # a path prefixed by /cygdrive for fixpath to work.
9304 new_path="$CYGWIN_ROOT_PATH$input_path"
9305 fi
9306 fi
9307
9308 # remove trailing .exe if any
9309 new_path="${new_path/%.exe/}"
9310
9311 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9312
9313 # First separate the path from the arguments. This will split at the first
9314 # space.
9315 complete="$FOUND_MAKE"
9316 path="${complete%% *}"
9317 tmp="$complete EOL"
9318 arguments="${tmp#* }"
9319
9320 # Input might be given as Windows format, start by converting to
9321 # unix format.
9322 new_path="$path"
9323
9324 windows_path="$new_path"
9325 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9326 unix_path=`$CYGPATH -u "$windows_path"`
9327 new_path="$unix_path"
9328 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9329 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
9330 new_path="$unix_path"
9331 fi
9332
9333
9334 # Now try to locate executable using which
9335 new_path=`$WHICH "$new_path" 2> /dev/null`
9336
9337 if test "x$new_path" = x; then
9338 # Oops. Which didn't find the executable.
9339 # The splitting of arguments from the executable at a space might have been incorrect,
9340 # since paths with space are more likely in Windows. Give it another try with the whole
9341 # argument.
9342 path="$complete"
9343 arguments="EOL"
9344 new_path="$path"
9345
9346 windows_path="$new_path"
9347 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9348 unix_path=`$CYGPATH -u "$windows_path"`
9349 new_path="$unix_path"
9350 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9351 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
9352 new_path="$unix_path"
9353 fi
9354
9355
9356 new_path=`$WHICH "$new_path" 2> /dev/null`
9357
9358 if test "x$new_path" = x; then
9359 # It's still not found. Now this is an unrecoverable error.
9360 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9361 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9362 has_space=`$ECHO "$complete" | $GREP " "`
9363 if test "x$has_space" != x; then
9364 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
9365 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
9366 fi
9367 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9368 fi
9369 fi
9370
9371 # Now new_path has a complete unix path to the binary
9372 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
9373 # Keep paths in /bin as-is, but remove trailing .exe if any
9374 new_path="${new_path/%.exe/}"
9375 # Do not save /bin paths to all_fixpath_prefixes!
9376 else
9377 # Not in mixed or Windows style, start by that.
9378 new_path=`cmd //c echo $new_path`
9379
9380 input_path="$new_path"
9381 # Check if we need to convert this using DOS-style short mode. If the path
9382 # contains just simple characters, use it. Otherwise (spaces, weird characters),
9383 # take no chances and rewrite it.
9384 # Note: m4 eats our [], so we need to use [ and ] instead.
9385 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
9386 if test "x$has_forbidden_chars" != x; then
9387 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
9388 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
9389 fi
9390
9391 # Output is in $new_path
9392
9393 windows_path="$new_path"
9394 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9395 unix_path=`$CYGPATH -u "$windows_path"`
9396 new_path="$unix_path"
9397 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9398 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
9399 new_path="$unix_path"
9400 fi
9401
9402 # remove trailing .exe if any
9403 new_path="${new_path/%.exe/}"
9404
9405 # Save the first 10 bytes of this path to the storage, so fixpath can work.
9406 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
9407 fi
9408
9409 else
9410 # We're on a posix platform. Hooray! :)
9411 # First separate the path from the arguments. This will split at the first
9412 # space.
9413 complete="$FOUND_MAKE"
9414 path="${complete%% *}"
9415 tmp="$complete EOL"
9416 arguments="${tmp#* }"
9417
9418 # Cannot rely on the command "which" here since it doesn't always work.
9419 is_absolute_path=`$ECHO "$path" | $GREP ^/`
9420 if test -z "$is_absolute_path"; then
9421 # Path to executable is not absolute. Find it.
9422 IFS_save="$IFS"
9423 IFS=:
9424 for p in $PATH; do
9425 if test -f "$p/$path" && test -x "$p/$path"; then
9426 new_path="$p/$path"
9427 break
9428 fi
9429 done
9430 IFS="$IFS_save"
9431 else
9432 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
9433 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
9434 new_path="$path"
9435 fi
9436
9437 if test "x$new_path" = x; then
9438 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9439 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9440 has_space=`$ECHO "$complete" | $GREP " "`
9441 if test "x$has_space" != x; then
9442 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
9443 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
9444 fi
9445 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9446 fi
9447 fi
9448
9449 # Now join together the path and the arguments once again
9450 if test "x$arguments" != xEOL; then
9451 new_complete="$new_path ${arguments% *}"
9452 else
9453 new_complete="$new_path"
9454 fi
9455
9456 if test "x$complete" != "x$new_complete"; then
9457 FOUND_MAKE="$new_complete"
9458 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
9459 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
9460 fi
9461
9462 fi
9463 fi
9464 fi
9465 fi
9466
9467 fi
9468
9469 if test "x$FOUND_MAKE" = x; then
9470 if test "x$TOOLS_DIR" != x; then
9471 # We have a tools-dir, check that as well before giving up.
9472 OLD_PATH=$PATH
9473 PATH=$TOOLS_DIR:$PATH
9474 for ac_prog in gmake
9475 do
9476 # Extract the first word of "$ac_prog", so it can be a program name with args.
9477 set dummy $ac_prog; ac_word=$2
9478 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9479 $as_echo_n "checking for $ac_word... " >&6; }
9480 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
9481 $as_echo_n "(cached) " >&6
9482 else
9483 case $CHECK_TOOLSDIR_GMAKE in
9484 [\\/]* | ?:[\\/]*)
9485 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
9486 ;;
9487 *)
9488 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9489 for as_dir in $PATH
9490 do
9491 IFS=$as_save_IFS
9492 test -z "$as_dir" && as_dir=.
9493 for ac_exec_ext in '' $ac_executable_extensions; do
9494 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9495 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
9496 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9497 break 2
9498 fi
9499 done
9500 done
9501 IFS=$as_save_IFS
9502
9503 ;;
9504 esac
9505 fi
9506 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
9507 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
9508 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
9509 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
9510 else
9511 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9512 $as_echo "no" >&6; }
9513 fi
9514
9515
9516 test -n "$CHECK_TOOLSDIR_GMAKE" && break
9517 done
9518
9519
9520 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
9521 DESCRIPTION="gmake in tools-dir"
9522 if test "x$MAKE_CANDIDATE" != x; then
9523 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
9524 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
9525 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
9526 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
9527 if test "x$IS_GNU_MAKE" = x; then
9528 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
9529 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
9530 else
9531 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
9532 if test "x$IS_MODERN_MAKE" = x; then
9533 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
9534 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
9535 else
9536 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
9537 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9538 MAKE_EXPECTED_ENV='cygwin'
9539 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9540 MAKE_EXPECTED_ENV='msys'
9541 else
9542 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
9543 fi
9544 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
9545 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
9546 else
9547 # Not relevant for non-Windows
9548 IS_MAKE_CORRECT_ENV=true
9549 fi
9550 if test "x$IS_MAKE_CORRECT_ENV" = x; then
9551 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
9552 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
9553 else
9554 FOUND_MAKE=$MAKE_CANDIDATE
9555
9556 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9557
9558 # First separate the path from the arguments. This will split at the first
9559 # space.
9560 complete="$FOUND_MAKE"
9561 path="${complete%% *}"
9562 tmp="$complete EOL"
9563 arguments="${tmp#* }"
9564
9565 # Input might be given as Windows format, start by converting to
9566 # unix format.
9567 new_path=`$CYGPATH -u "$path"`
9568
9569 # Now try to locate executable using which
9570 new_path=`$WHICH "$new_path" 2> /dev/null`
9571 # bat and cmd files are not always considered executable in cygwin causing which
9572 # to not find them
9573 if test "x$new_path" = x \
9574 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
9575 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
9576 new_path=`$CYGPATH -u "$path"`
9577 fi
9578 if test "x$new_path" = x; then
9579 # Oops. Which didn't find the executable.
9580 # The splitting of arguments from the executable at a space might have been incorrect,
9581 # since paths with space are more likely in Windows. Give it another try with the whole
9582 # argument.
9583 path="$complete"
9584 arguments="EOL"
9585 new_path=`$CYGPATH -u "$path"`
9586 new_path=`$WHICH "$new_path" 2> /dev/null`
9587 # bat and cmd files are not always considered executable in cygwin causing which
9588 # to not find them
9589 if test "x$new_path" = x \
9590 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
9591 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
9592 new_path=`$CYGPATH -u "$path"`
9593 fi
9594 if test "x$new_path" = x; then
9595 # It's still not found. Now this is an unrecoverable error.
9596 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9597 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9598 has_space=`$ECHO "$complete" | $GREP " "`
9599 if test "x$has_space" != x; then
9600 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
9601 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
9602 fi
9603 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9604 fi
9605 fi
9606
9607 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
9608 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
9609 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
9610 # "foo.exe" is OK but "foo" is an error.
9611 #
9612 # This test is therefore slightly more accurate than "test -f" to check for file presence.
9613 # It is also a way to make sure we got the proper file name for the real test later on.
9614 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
9615 if test "x$test_shortpath" = x; then
9616 # Short path failed, file does not exist as specified.
9617 # Try adding .exe or .cmd
9618 if test -f "${new_path}.exe"; then
9619 input_to_shortpath="${new_path}.exe"
9620 elif test -f "${new_path}.cmd"; then
9621 input_to_shortpath="${new_path}.cmd"
9622 else
9623 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
9624 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
9625 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
9626 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
9627 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9628 fi
9629 else
9630 input_to_shortpath="$new_path"
9631 fi
9632
9633 # Call helper function which possibly converts this using DOS-style short mode.
9634 # If so, the updated path is stored in $new_path.
9635 new_path="$input_to_shortpath"
9636
9637 input_path="$input_to_shortpath"
9638 # Check if we need to convert this using DOS-style short mode. If the path
9639 # contains just simple characters, use it. Otherwise (spaces, weird characters),
9640 # take no chances and rewrite it.
9641 # Note: m4 eats our [], so we need to use [ and ] instead.
9642 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
9643 if test "x$has_forbidden_chars" != x; then
9644 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
9645 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
9646 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
9647 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
9648 # Going to short mode and back again did indeed matter. Since short mode is
9649 # case insensitive, let's make it lowercase to improve readability.
9650 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
9651 # Now convert it back to Unix-stile (cygpath)
9652 input_path=`$CYGPATH -u "$shortmode_path"`
9653 new_path="$input_path"
9654 fi
9655 fi
9656
9657 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
9658 if test "x$test_cygdrive_prefix" = x; then
9659 # As a simple fix, exclude /usr/bin since it's not a real path.
9660 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
9661 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
9662 # a path prefixed by /cygdrive for fixpath to work.
9663 new_path="$CYGWIN_ROOT_PATH$input_path"
9664 fi
9665 fi
9666
9667 # remove trailing .exe if any
9668 new_path="${new_path/%.exe/}"
9669
9670 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9671
9672 # First separate the path from the arguments. This will split at the first
9673 # space.
9674 complete="$FOUND_MAKE"
9675 path="${complete%% *}"
9676 tmp="$complete EOL"
9677 arguments="${tmp#* }"
9678
9679 # Input might be given as Windows format, start by converting to
9680 # unix format.
9681 new_path="$path"
9682
9683 windows_path="$new_path"
9684 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9685 unix_path=`$CYGPATH -u "$windows_path"`
9686 new_path="$unix_path"
9687 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9688 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
9689 new_path="$unix_path"
9690 fi
9691
9692
9693 # Now try to locate executable using which
9694 new_path=`$WHICH "$new_path" 2> /dev/null`
9695
9696 if test "x$new_path" = x; then
9697 # Oops. Which didn't find the executable.
9698 # The splitting of arguments from the executable at a space might have been incorrect,
9699 # since paths with space are more likely in Windows. Give it another try with the whole
9700 # argument.
9701 path="$complete"
9702 arguments="EOL"
9703 new_path="$path"
9704
9705 windows_path="$new_path"
9706 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9707 unix_path=`$CYGPATH -u "$windows_path"`
9708 new_path="$unix_path"
9709 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9710 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
9711 new_path="$unix_path"
9712 fi
9713
9714
9715 new_path=`$WHICH "$new_path" 2> /dev/null`
9716
9717 if test "x$new_path" = x; then
9718 # It's still not found. Now this is an unrecoverable error.
9719 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9720 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9721 has_space=`$ECHO "$complete" | $GREP " "`
9722 if test "x$has_space" != x; then
9723 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
9724 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
9725 fi
9726 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9727 fi
9728 fi
9729
9730 # Now new_path has a complete unix path to the binary
9731 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
9732 # Keep paths in /bin as-is, but remove trailing .exe if any
9733 new_path="${new_path/%.exe/}"
9734 # Do not save /bin paths to all_fixpath_prefixes!
9735 else
9736 # Not in mixed or Windows style, start by that.
9737 new_path=`cmd //c echo $new_path`
9738
9739 input_path="$new_path"
9740 # Check if we need to convert this using DOS-style short mode. If the path
9741 # contains just simple characters, use it. Otherwise (spaces, weird characters),
9742 # take no chances and rewrite it.
9743 # Note: m4 eats our [], so we need to use [ and ] instead.
9744 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
9745 if test "x$has_forbidden_chars" != x; then
9746 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
9747 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
9748 fi
9749
9750 # Output is in $new_path
9751
9752 windows_path="$new_path"
9753 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9754 unix_path=`$CYGPATH -u "$windows_path"`
9755 new_path="$unix_path"
9756 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9757 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
9758 new_path="$unix_path"
9759 fi
9760
9761 # remove trailing .exe if any
9762 new_path="${new_path/%.exe/}"
9763
9764 # Save the first 10 bytes of this path to the storage, so fixpath can work.
9765 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
9766 fi
9767
9768 else
9769 # We're on a posix platform. Hooray! :)
9770 # First separate the path from the arguments. This will split at the first
9771 # space.
9772 complete="$FOUND_MAKE"
9773 path="${complete%% *}"
9774 tmp="$complete EOL"
9775 arguments="${tmp#* }"
9776
9777 # Cannot rely on the command "which" here since it doesn't always work.
9778 is_absolute_path=`$ECHO "$path" | $GREP ^/`
9779 if test -z "$is_absolute_path"; then
9780 # Path to executable is not absolute. Find it.
9781 IFS_save="$IFS"
9782 IFS=:
9783 for p in $PATH; do
9784 if test -f "$p/$path" && test -x "$p/$path"; then
9785 new_path="$p/$path"
9786 break
9787 fi
9788 done
9789 IFS="$IFS_save"
9790 else
9791 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
9792 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
9793 new_path="$path"
9794 fi
9795
9796 if test "x$new_path" = x; then
9797 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9798 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9799 has_space=`$ECHO "$complete" | $GREP " "`
9800 if test "x$has_space" != x; then
9801 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
9802 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
9803 fi
9804 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9805 fi
9806 fi
9807
9808 # Now join together the path and the arguments once again
9809 if test "x$arguments" != xEOL; then
9810 new_complete="$new_path ${arguments% *}"
9811 else
9812 new_complete="$new_path"
9813 fi
9814
9815 if test "x$complete" != "x$new_complete"; then
9816 FOUND_MAKE="$new_complete"
9817 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
9818 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
9819 fi
9820
9821 fi
9822 fi
9823 fi
9824 fi
9825
9826 if test "x$FOUND_MAKE" = x; then
9827 for ac_prog in make
9828 do
9829 # Extract the first word of "$ac_prog", so it can be a program name with args.
9830 set dummy $ac_prog; ac_word=$2
9831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9832 $as_echo_n "checking for $ac_word... " >&6; }
9833 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
9834 $as_echo_n "(cached) " >&6
9835 else
9836 case $CHECK_TOOLSDIR_MAKE in
9837 [\\/]* | ?:[\\/]*)
9838 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
9839 ;;
9840 *)
9841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9842 for as_dir in $PATH
9843 do
9844 IFS=$as_save_IFS
9845 test -z "$as_dir" && as_dir=.
9846 for ac_exec_ext in '' $ac_executable_extensions; do
9847 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9848 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
9849 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9850 break 2
9851 fi
9852 done
9853 done
9854 IFS=$as_save_IFS
9855
9856 ;;
9857 esac
9858 fi
9859 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
9860 if test -n "$CHECK_TOOLSDIR_MAKE"; then
9861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
9862 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
9863 else
9864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9865 $as_echo "no" >&6; }
9866 fi
9867
9868
9869 test -n "$CHECK_TOOLSDIR_MAKE" && break
9870 done
9871
9872
9873 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
9874 DESCRIPTION="make in tools-dir"
9875 if test "x$MAKE_CANDIDATE" != x; then
9876 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
9877 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
9878 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
9879 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
9880 if test "x$IS_GNU_MAKE" = x; then
9881 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
9882 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
9883 else
9884 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
9885 if test "x$IS_MODERN_MAKE" = x; then
9886 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
9887 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
9888 else
9889 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
9890 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9891 MAKE_EXPECTED_ENV='cygwin'
9892 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
9893 MAKE_EXPECTED_ENV='msys'
9894 else
9895 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
9896 fi
9897 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
9898 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
9899 else
9900 # Not relevant for non-Windows
9901 IS_MAKE_CORRECT_ENV=true
9902 fi
9903 if test "x$IS_MAKE_CORRECT_ENV" = x; then
9904 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
9905 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
9906 else
9907 FOUND_MAKE=$MAKE_CANDIDATE
9908
9909 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
9910
9911 # First separate the path from the arguments. This will split at the first
9912 # space.
9913 complete="$FOUND_MAKE"
9914 path="${complete%% *}"
9915 tmp="$complete EOL"
9916 arguments="${tmp#* }"
9917
9918 # Input might be given as Windows format, start by converting to
9919 # unix format.
9920 new_path=`$CYGPATH -u "$path"`
9921
9922 # Now try to locate executable using which
9923 new_path=`$WHICH "$new_path" 2> /dev/null`
9924 # bat and cmd files are not always considered executable in cygwin causing which
9925 # to not find them
9926 if test "x$new_path" = x \
9927 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
9928 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
9929 new_path=`$CYGPATH -u "$path"`
9930 fi
9931 if test "x$new_path" = x; then
9932 # Oops. Which didn't find the executable.
9933 # The splitting of arguments from the executable at a space might have been incorrect,
9934 # since paths with space are more likely in Windows. Give it another try with the whole
9935 # argument.
9936 path="$complete"
9937 arguments="EOL"
9938 new_path=`$CYGPATH -u "$path"`
9939 new_path=`$WHICH "$new_path" 2> /dev/null`
9940 # bat and cmd files are not always considered executable in cygwin causing which
9941 # to not find them
9942 if test "x$new_path" = x \
9943 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
9944 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
9945 new_path=`$CYGPATH -u "$path"`
9946 fi
9947 if test "x$new_path" = x; then
9948 # It's still not found. Now this is an unrecoverable error.
9949 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
9950 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
9951 has_space=`$ECHO "$complete" | $GREP " "`
9952 if test "x$has_space" != x; then
9953 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
9954 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
9955 fi
9956 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9957 fi
9958 fi
9959
9960 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
9961 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
9962 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
9963 # "foo.exe" is OK but "foo" is an error.
9964 #
9965 # This test is therefore slightly more accurate than "test -f" to check for file presence.
9966 # It is also a way to make sure we got the proper file name for the real test later on.
9967 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
9968 if test "x$test_shortpath" = x; then
9969 # Short path failed, file does not exist as specified.
9970 # Try adding .exe or .cmd
9971 if test -f "${new_path}.exe"; then
9972 input_to_shortpath="${new_path}.exe"
9973 elif test -f "${new_path}.cmd"; then
9974 input_to_shortpath="${new_path}.cmd"
9975 else
9976 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
9977 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
9978 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
9979 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
9980 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
9981 fi
9982 else
9983 input_to_shortpath="$new_path"
9984 fi
9985
9986 # Call helper function which possibly converts this using DOS-style short mode.
9987 # If so, the updated path is stored in $new_path.
9988 new_path="$input_to_shortpath"
9989
9990 input_path="$input_to_shortpath"
9991 # Check if we need to convert this using DOS-style short mode. If the path
9992 # contains just simple characters, use it. Otherwise (spaces, weird characters),
9993 # take no chances and rewrite it.
9994 # Note: m4 eats our [], so we need to use [ and ] instead.
9995 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
9996 if test "x$has_forbidden_chars" != x; then
9997 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
9998 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
9999 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
10000 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
10001 # Going to short mode and back again did indeed matter. Since short mode is
10002 # case insensitive, let's make it lowercase to improve readability.
10003 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
10004 # Now convert it back to Unix-stile (cygpath)
10005 input_path=`$CYGPATH -u "$shortmode_path"`
10006 new_path="$input_path"
10007 fi
10008 fi
10009
10010 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
10011 if test "x$test_cygdrive_prefix" = x; then
10012 # As a simple fix, exclude /usr/bin since it's not a real path.
10013 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
10014 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
10015 # a path prefixed by /cygdrive for fixpath to work.
10016 new_path="$CYGWIN_ROOT_PATH$input_path"
10017 fi
10018 fi
10019
10020 # remove trailing .exe if any
10021 new_path="${new_path/%.exe/}"
10022
10023 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
10024
10025 # First separate the path from the arguments. This will split at the first
10026 # space.
10027 complete="$FOUND_MAKE"
10028 path="${complete%% *}"
10029 tmp="$complete EOL"
10030 arguments="${tmp#* }"
10031
10032 # Input might be given as Windows format, start by converting to
10033 # unix format.
10034 new_path="$path"
10035
10036 windows_path="$new_path"
10037 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
10038 unix_path=`$CYGPATH -u "$windows_path"`
10039 new_path="$unix_path"
10040 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
10041 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
10042 new_path="$unix_path"
10043 fi
10044
10045
10046 # Now try to locate executable using which
10047 new_path=`$WHICH "$new_path" 2> /dev/null`
10048
10049 if test "x$new_path" = x; then
10050 # Oops. Which didn't find the executable.
10051 # The splitting of arguments from the executable at a space might have been incorrect,
10052 # since paths with space are more likely in Windows. Give it another try with the whole
10053 # argument.
10054 path="$complete"
10055 arguments="EOL"
10056 new_path="$path"
10057
10058 windows_path="$new_path"
10059 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
10060 unix_path=`$CYGPATH -u "$windows_path"`
10061 new_path="$unix_path"
10062 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
10063 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
10064 new_path="$unix_path"
10065 fi
10066
10067
10068 new_path=`$WHICH "$new_path" 2> /dev/null`
10069
10070 if test "x$new_path" = x; then
10071 # It's still not found. Now this is an unrecoverable error.
10072 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
10073 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
10074 has_space=`$ECHO "$complete" | $GREP " "`
10075 if test "x$has_space" != x; then
10076 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
10077 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
10078 fi
10079 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
10080 fi
10081 fi
10082
10083 # Now new_path has a complete unix path to the binary
10084 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
10085 # Keep paths in /bin as-is, but remove trailing .exe if any
10086 new_path="${new_path/%.exe/}"
10087 # Do not save /bin paths to all_fixpath_prefixes!
10088 else
10089 # Not in mixed or Windows style, start by that.
10090 new_path=`cmd //c echo $new_path`
10091
10092 input_path="$new_path"
10093 # Check if we need to convert this using DOS-style short mode. If the path
10094 # contains just simple characters, use it. Otherwise (spaces, weird characters),
10095 # take no chances and rewrite it.
10096 # Note: m4 eats our [], so we need to use [ and ] instead.
10097 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
10098 if test "x$has_forbidden_chars" != x; then
10099 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
10100 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
10101 fi
10102
10103 # Output is in $new_path
10104
10105 windows_path="$new_path"
10106 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
10107 unix_path=`$CYGPATH -u "$windows_path"`
10108 new_path="$unix_path"
10109 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
10110 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
10111 new_path="$unix_path"
10112 fi
10113
10114 # remove trailing .exe if any
10115 new_path="${new_path/%.exe/}"
10116
10117 # Save the first 10 bytes of this path to the storage, so fixpath can work.
10118 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
10119 fi
10120
10121 else
10122 # We're on a posix platform. Hooray! :)
10123 # First separate the path from the arguments. This will split at the first
10124 # space.
10125 complete="$FOUND_MAKE"
10126 path="${complete%% *}"
10127 tmp="$complete EOL"
10128 arguments="${tmp#* }"
10129
10130 # Cannot rely on the command "which" here since it doesn't always work.
10131 is_absolute_path=`$ECHO "$path" | $GREP ^/`
10132 if test -z "$is_absolute_path"; then
10133 # Path to executable is not absolute. Find it.
10134 IFS_save="$IFS"
10135 IFS=:
10136 for p in $PATH; do
10137 if test -f "$p/$path" && test -x "$p/$path"; then
10138 new_path="$p/$path"
10139 break
10140 fi
10141 done
10142 IFS="$IFS_save"
10143 else
10144 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
10145 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
10146 new_path="$path"
10147 fi
10148
10149 if test "x$new_path" = x; then
10150 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
10151 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
10152 has_space=`$ECHO "$complete" | $GREP " "`
10153 if test "x$has_space" != x; then
10154 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
10155 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
10156 fi
10157 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
10158 fi
10159 fi
10160
10161 # Now join together the path and the arguments once again
10162 if test "x$arguments" != xEOL; then
10163 new_complete="$new_path ${arguments% *}"
10164 else
10165 new_complete="$new_path"
10166 fi
10167
10168 if test "x$complete" != "x$new_complete"; then
10169 FOUND_MAKE="$new_complete"
10170 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
10171 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
10172 fi
10173
10174 fi
10175 fi
10176 fi
10177 fi
10178
10179 fi
10180 PATH=$OLD_PATH
10181 fi
10182 fi
10183
10184 if test "x$FOUND_MAKE" = x; then
10185 as_fn_error $? "Cannot find GNU make 3.81 or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
10186 fi
10187 fi
10188
10189 MAKE=$FOUND_MAKE
10190
10191 { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
10192 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
10193
10194
10195
10196 # Test if find supports -delete
10197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
10198 $as_echo_n "checking if find supports -delete... " >&6; }
10199 FIND_DELETE="-delete"
10200
10201 DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
10202
10203 echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
10204
10205 TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
10206 if test -f $DELETEDIR/TestIfFindSupportsDelete; then
10207 # No, it does not.
10208 rm $DELETEDIR/TestIfFindSupportsDelete
10209 FIND_DELETE="-exec rm \{\} \+"
10210 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10211 $as_echo "no" >&6; }
10212 else
10213 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
10214 $as_echo "yes" >&6; }
10215 fi
10216 rmdir $DELETEDIR
10217
10218
10219
10220 # These tools might not be installed by default,
10221 # need hint on how to install them.
10222
10223 for ac_prog in unzip
10224 do
10225 # Extract the first word of "$ac_prog", so it can be a program name with args.
10226 set dummy $ac_prog; ac_word=$2
10227 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10228 $as_echo_n "checking for $ac_word... " >&6; }
10229 if ${ac_cv_path_UNZIP+:} false; then :
10230 $as_echo_n "(cached) " >&6
10231 else
10232 case $UNZIP in
10233 [\\/]* | ?:[\\/]*)
10234 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
10235 ;;
10236 *)
10237 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10238 for as_dir in $PATH
10239 do
10240 IFS=$as_save_IFS
10241 test -z "$as_dir" && as_dir=.
10242 for ac_exec_ext in '' $ac_executable_extensions; do
10243 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10244 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
10245 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10246 break 2
10247 fi
10248 done
10249 done
10250 IFS=$as_save_IFS
10251
10252 ;;
10253 esac
10254 fi
10255 UNZIP=$ac_cv_path_UNZIP
10256 if test -n "$UNZIP"; then
10257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
10258 $as_echo "$UNZIP" >&6; }
10259 else
10260 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10261 $as_echo "no" >&6; }
10262 fi
10263
10264
10265 test -n "$UNZIP" && break
10266 done
10267
10268
10269 if test "x$UNZIP" = x; then
10270 if test "xunzip" = x; then
10271 PROG_NAME=unzip
10272 else
10273 PROG_NAME=unzip
10274 fi
10275 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
10276 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
10277 as_fn_error $? "Cannot continue" "$LINENO" 5
10278 fi
10279
10280
10281
10282 for ac_prog in zip
10283 do
10284 # Extract the first word of "$ac_prog", so it can be a program name with args.
10285 set dummy $ac_prog; ac_word=$2
10286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10287 $as_echo_n "checking for $ac_word... " >&6; }
10288 if ${ac_cv_path_ZIP+:} false; then :
10289 $as_echo_n "(cached) " >&6
10290 else
10291 case $ZIP in
10292 [\\/]* | ?:[\\/]*)
10293 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
10294 ;;
10295 *)
10296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10297 for as_dir in $PATH
10298 do
10299 IFS=$as_save_IFS
10300 test -z "$as_dir" && as_dir=.
10301 for ac_exec_ext in '' $ac_executable_extensions; do
10302 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10303 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
10304 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10305 break 2
10306 fi
10307 done
10308 done
10309 IFS=$as_save_IFS
10310
10311 ;;
10312 esac
10313 fi
10314 ZIP=$ac_cv_path_ZIP
10315 if test -n "$ZIP"; then
10316 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
10317 $as_echo "$ZIP" >&6; }
10318 else
10319 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10320 $as_echo "no" >&6; }
10321 fi
10322
10323
10324 test -n "$ZIP" && break
10325 done
10326
10327
10328 if test "x$ZIP" = x; then
10329 if test "xzip" = x; then
10330 PROG_NAME=zip
10331 else
10332 PROG_NAME=zip
10333 fi
10334 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
10335 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
10336 as_fn_error $? "Cannot continue" "$LINENO" 5
10337 fi
10338
10339
10340
10341 # Non-required basic tools
10342
10343 # Extract the first word of "ldd", so it can be a program name with args.
10344 set dummy ldd; ac_word=$2
10345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10346 $as_echo_n "checking for $ac_word... " >&6; }
10347 if ${ac_cv_path_LDD+:} false; then :
10348 $as_echo_n "(cached) " >&6
10349 else
10350 case $LDD in
10351 [\\/]* | ?:[\\/]*)
10352 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
10353 ;;
10354 *)
10355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10356 for as_dir in $PATH
10357 do
10358 IFS=$as_save_IFS
10359 test -z "$as_dir" && as_dir=.
10360 for ac_exec_ext in '' $ac_executable_extensions; do
10361 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10362 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
10363 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10364 break 2
10365 fi
10366 done
10367 done
10368 IFS=$as_save_IFS
10369
10370 ;;
10371 esac
10372 fi
10373 LDD=$ac_cv_path_LDD
10374 if test -n "$LDD"; then
10375 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
10376 $as_echo "$LDD" >&6; }
10377 else
10378 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10379 $as_echo "no" >&6; }
10380 fi
10381
10382
10383 if test "x$LDD" = "x"; then
10384 # List shared lib dependencies is used for
10385 # debug output and checking for forbidden dependencies.
10386 # We can build without it.
10387 LDD="true"
10388 fi
10389 for ac_prog in readelf greadelf
10390 do
10391 # Extract the first word of "$ac_prog", so it can be a program name with args.
10392 set dummy $ac_prog; ac_word=$2
10393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10394 $as_echo_n "checking for $ac_word... " >&6; }
10395 if ${ac_cv_path_READELF+:} false; then :
10396 $as_echo_n "(cached) " >&6
10397 else
10398 case $READELF in
10399 [\\/]* | ?:[\\/]*)
10400 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
10401 ;;
10402 *)
10403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 for as_dir in $PATH
10405 do
10406 IFS=$as_save_IFS
10407 test -z "$as_dir" && as_dir=.
10408 for ac_exec_ext in '' $ac_executable_extensions; do
10409 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
10411 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10412 break 2
10413 fi
10414 done
10415 done
10416 IFS=$as_save_IFS
10417
10418 ;;
10419 esac
10420 fi
10421 READELF=$ac_cv_path_READELF
10422 if test -n "$READELF"; then
10423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
10424 $as_echo "$READELF" >&6; }
10425 else
10426 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10427 $as_echo "no" >&6; }
10428 fi
10429
10430
10431 test -n "$READELF" && break
10432 done
10433
10434 # Extract the first word of "hg", so it can be a program name with args.
10435 set dummy hg; ac_word=$2
10436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10437 $as_echo_n "checking for $ac_word... " >&6; }
10438 if ${ac_cv_path_HG+:} false; then :
10439 $as_echo_n "(cached) " >&6
10440 else
10441 case $HG in
10442 [\\/]* | ?:[\\/]*)
10443 ac_cv_path_HG="$HG" # Let the user override the test with a path.
10444 ;;
10445 *)
10446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10447 for as_dir in $PATH
10448 do
10449 IFS=$as_save_IFS
10450 test -z "$as_dir" && as_dir=.
10451 for ac_exec_ext in '' $ac_executable_extensions; do
10452 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10453 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
10454 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10455 break 2
10456 fi
10457 done
10458 done
10459 IFS=$as_save_IFS
10460
10461 ;;
10462 esac
10463 fi
10464 HG=$ac_cv_path_HG
10465 if test -n "$HG"; then
10466 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
10467 $as_echo "$HG" >&6; }
10468 else
10469 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10470 $as_echo "no" >&6; }
10471 fi
10472
10473
10474 # Extract the first word of "stat", so it can be a program name with args.
10475 set dummy stat; ac_word=$2
10476 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10477 $as_echo_n "checking for $ac_word... " >&6; }
10478 if ${ac_cv_path_STAT+:} false; then :
10479 $as_echo_n "(cached) " >&6
10480 else
10481 case $STAT in
10482 [\\/]* | ?:[\\/]*)
10483 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
10484 ;;
10485 *)
10486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10487 for as_dir in $PATH
10488 do
10489 IFS=$as_save_IFS
10490 test -z "$as_dir" && as_dir=.
10491 for ac_exec_ext in '' $ac_executable_extensions; do
10492 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10493 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
10494 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10495 break 2
10496 fi
10497 done
10498 done
10499 IFS=$as_save_IFS
10500
10501 ;;
10502 esac
10503 fi
10504 STAT=$ac_cv_path_STAT
10505 if test -n "$STAT"; then
10506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
10507 $as_echo "$STAT" >&6; }
10508 else
10509 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10510 $as_echo "no" >&6; }
10511 fi
10512
10513
10514 # Extract the first word of "time", so it can be a program name with args.
10515 set dummy time; ac_word=$2
10516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10517 $as_echo_n "checking for $ac_word... " >&6; }
10518 if ${ac_cv_path_TIME+:} false; then :
10519 $as_echo_n "(cached) " >&6
10520 else
10521 case $TIME in
10522 [\\/]* | ?:[\\/]*)
10523 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
10524 ;;
10525 *)
10526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10527 for as_dir in $PATH
10528 do
10529 IFS=$as_save_IFS
10530 test -z "$as_dir" && as_dir=.
10531 for ac_exec_ext in '' $ac_executable_extensions; do
10532 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10533 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
10534 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10535 break 2
10536 fi
10537 done
10538 done
10539 IFS=$as_save_IFS
10540
10541 ;;
10542 esac
10543 fi
10544 TIME=$ac_cv_path_TIME
10545 if test -n "$TIME"; then
10546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
10547 $as_echo "$TIME" >&6; }
10548 else
10549 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10550 $as_echo "no" >&6; }
10551 fi
10552
10553
10554 # Check if it's GNU time
10555 IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
10556 if test "x$IS_GNU_TIME" != x; then
10557 IS_GNU_TIME=yes
10558 else
10559 IS_GNU_TIME=no
10560 fi
10561
10562
10563 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
10564
10565 for ac_prog in comm
10566 do
10567 # Extract the first word of "$ac_prog", so it can be a program name with args.
10568 set dummy $ac_prog; ac_word=$2
10569 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10570 $as_echo_n "checking for $ac_word... " >&6; }
10571 if ${ac_cv_path_COMM+:} false; then :
10572 $as_echo_n "(cached) " >&6
10573 else
10574 case $COMM in
10575 [\\/]* | ?:[\\/]*)
10576 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
10577 ;;
10578 *)
10579 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10580 for as_dir in $PATH
10581 do
10582 IFS=$as_save_IFS
10583 test -z "$as_dir" && as_dir=.
10584 for ac_exec_ext in '' $ac_executable_extensions; do
10585 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10586 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
10587 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10588 break 2
10589 fi
10590 done
10591 done
10592 IFS=$as_save_IFS
10593
10594 ;;
10595 esac
10596 fi
10597 COMM=$ac_cv_path_COMM
10598 if test -n "$COMM"; then
10599 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
10600 $as_echo "$COMM" >&6; }
10601 else
10602 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10603 $as_echo "no" >&6; }
10604 fi
10605
10606
10607 test -n "$COMM" && break
10608 done
10609
10610
10611 if test "x$COMM" = x; then
10612 if test "xcomm" = x; then
10613 PROG_NAME=comm
10614 else
10615 PROG_NAME=comm
10616 fi
10617 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
10618 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
10619 as_fn_error $? "Cannot continue" "$LINENO" 5
10620 fi
10621
10622
10623 fi
10624
10625 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
10626
10627 for ac_prog in dsymutil
10628 do
10629 # Extract the first word of "$ac_prog", so it can be a program name with args.
10630 set dummy $ac_prog; ac_word=$2
10631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10632 $as_echo_n "checking for $ac_word... " >&6; }
10633 if ${ac_cv_path_DSYMUTIL+:} false; then :
10634 $as_echo_n "(cached) " >&6
10635 else
10636 case $DSYMUTIL in
10637 [\\/]* | ?:[\\/]*)
10638 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
10639 ;;
10640 *)
10641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10642 for as_dir in $PATH
10643 do
10644 IFS=$as_save_IFS
10645 test -z "$as_dir" && as_dir=.
10646 for ac_exec_ext in '' $ac_executable_extensions; do
10647 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10648 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
10649 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10650 break 2
10651 fi
10652 done
10653 done
10654 IFS=$as_save_IFS
10655
10656 ;;
10657 esac
10658 fi
10659 DSYMUTIL=$ac_cv_path_DSYMUTIL
10660 if test -n "$DSYMUTIL"; then
10661 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
10662 $as_echo "$DSYMUTIL" >&6; }
10663 else
10664 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10665 $as_echo "no" >&6; }
10666 fi
10667
10668
10669 test -n "$DSYMUTIL" && break
10670 done
10671
10672
10673 if test "x$DSYMUTIL" = x; then
10674 if test "xdsymutil" = x; then
10675 PROG_NAME=dsymutil
10676 else
10677 PROG_NAME=dsymutil
10678 fi
10679 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
10680 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
10681 as_fn_error $? "Cannot continue" "$LINENO" 5
10682 fi
10683
10684
10685
10686 for ac_prog in xattr
10687 do
10688 # Extract the first word of "$ac_prog", so it can be a program name with args.
10689 set dummy $ac_prog; ac_word=$2
10690 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10691 $as_echo_n "checking for $ac_word... " >&6; }
10692 if ${ac_cv_path_XATTR+:} false; then :
10693 $as_echo_n "(cached) " >&6
10694 else
10695 case $XATTR in
10696 [\\/]* | ?:[\\/]*)
10697 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
10698 ;;
10699 *)
10700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10701 for as_dir in $PATH
10702 do
10703 IFS=$as_save_IFS
10704 test -z "$as_dir" && as_dir=.
10705 for ac_exec_ext in '' $ac_executable_extensions; do
10706 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10707 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
10708 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10709 break 2
10710 fi
10711 done
10712 done
10713 IFS=$as_save_IFS
10714
10715 ;;
10716 esac
10717 fi
10718 XATTR=$ac_cv_path_XATTR
10719 if test -n "$XATTR"; then
10720 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
10721 $as_echo "$XATTR" >&6; }
10722 else
10723 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10724 $as_echo "no" >&6; }
10725 fi
10726
10727
10728 test -n "$XATTR" && break
10729 done
10730
10731
10732 if test "x$XATTR" = x; then
10733 if test "xxattr" = x; then
10734 PROG_NAME=xattr
10735 else
10736 PROG_NAME=xattr
10737 fi
10738 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
10739 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
10740 as_fn_error $? "Cannot continue" "$LINENO" 5
10741 fi
10742
10743
10744 # Extract the first word of "codesign", so it can be a program name with args.
10745 set dummy codesign; ac_word=$2
10746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10747 $as_echo_n "checking for $ac_word... " >&6; }
10748 if ${ac_cv_path_CODESIGN+:} false; then :
10749 $as_echo_n "(cached) " >&6
10750 else
10751 case $CODESIGN in
10752 [\\/]* | ?:[\\/]*)
10753 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
10754 ;;
10755 *)
10756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10757 for as_dir in $PATH
10758 do
10759 IFS=$as_save_IFS
10760 test -z "$as_dir" && as_dir=.
10761 for ac_exec_ext in '' $ac_executable_extensions; do
10762 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10763 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
10764 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10765 break 2
10766 fi
10767 done
10768 done
10769 IFS=$as_save_IFS
10770
10771 ;;
10772 esac
10773 fi
10774 CODESIGN=$ac_cv_path_CODESIGN
10775 if test -n "$CODESIGN"; then
10776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
10777 $as_echo "$CODESIGN" >&6; }
10778 else
10779 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10780 $as_echo "no" >&6; }
10781 fi
10782
10783
10784 if test "x$CODESIGN" != "x"; then
10785 # Verify that the openjdk_codesign certificate is present
10786 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
10787 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
10788 rm -f codesign-testfile
10789 touch codesign-testfile
10790 codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
10791 rm -f codesign-testfile
10792 if test "x$CODESIGN" = x; then
10793 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10794 $as_echo "no" >&6; }
10795 else
10796 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
10797 $as_echo "yes" >&6; }
10798 fi
10799 fi
10800 fi
10801
10802
10803 # Check if pkg-config is available.
16825 if test ! -f "$path" && test ! -d "$path"; then
16826 as_fn_error $? "The path of JT_HOME, which resolves as \"$path\", is not found." "$LINENO" 5
16827 fi
16828
16829 JT_HOME="`cd "$path"; $THEPWDCMD -L`"
16830 fi
16831
16832
16833 # jtreg win32 script works for everybody
16834 JTREGEXE="$JT_HOME/bin/jtreg"
16835
16836 if test ! -f "$JTREGEXE"; then
16837 as_fn_error $? "JTReg executable does not exist: $JTREGEXE" "$LINENO" 5
16838 fi
16839
16840 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
16841 $as_echo "$JTREGEXE" >&6; }
16842 else
16843 # try to find jtreg on path
16844
16845 for ac_prog in jtreg
16846 do
16847 # Extract the first word of "$ac_prog", so it can be a program name with args.
16848 set dummy $ac_prog; ac_word=$2
16849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16850 $as_echo_n "checking for $ac_word... " >&6; }
16851 if ${ac_cv_path_JTREGEXE+:} false; then :
16852 $as_echo_n "(cached) " >&6
16853 else
16854 case $JTREGEXE in
16855 [\\/]* | ?:[\\/]*)
16856 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
16857 ;;
16858 *)
16859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16860 for as_dir in $PATH
16861 do
16862 IFS=$as_save_IFS
16863 test -z "$as_dir" && as_dir=.
16864 for ac_exec_ext in '' $ac_executable_extensions; do
16870 done
16871 done
16872 IFS=$as_save_IFS
16873
16874 ;;
16875 esac
16876 fi
16877 JTREGEXE=$ac_cv_path_JTREGEXE
16878 if test -n "$JTREGEXE"; then
16879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
16880 $as_echo "$JTREGEXE" >&6; }
16881 else
16882 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16883 $as_echo "no" >&6; }
16884 fi
16885
16886
16887 test -n "$JTREGEXE" && break
16888 done
16889
16890
16891 if test "x$JTREGEXE" = x; then
16892 if test "xjtreg" = x; then
16893 PROG_NAME=jtregexe
16894 else
16895 PROG_NAME=jtreg
16896 fi
16897 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
16898 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
16899 as_fn_error $? "Cannot continue" "$LINENO" 5
16900 fi
16901
16902
16903 JT_HOME="`$DIRNAME $JTREGEXE`"
16904 fi
16905 fi
16906
16907
16908
16909
16910
16911 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
16912
16913 # Store path to cygwin link.exe to help excluding it when searching for
16914 # VS linker. This must be done before changing the PATH when looking for VS.
16915 # Extract the first word of "link", so it can be a program name with args.
16916 set dummy link; ac_word=$2
16917 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16918 $as_echo_n "checking for $ac_word... " >&6; }
16919 if ${ac_cv_path_CYGWIN_LINK+:} false; then :
18168
18169
18170
18171 # If --build AND --host is set, then the configure script will find any
18172 # cross compilation tools in the PATH. Cross compilation tools
18173 # follows the cross compilation standard where they are prefixed with ${host}.
18174 # For example the binary i686-sun-solaris2.10-gcc
18175 # will cross compile for i686-sun-solaris2.10
18176 # If neither of build and host is not set, then build=host and the
18177 # default compiler found in the path will be used.
18178 # Setting only --host, does not seem to be really supported.
18179 # Please set both --build and --host if you want to cross compile.
18180
18181 if test "x$COMPILE_TYPE" = "xcross"; then
18182 # Now we to find a C/C++ compiler that can build executables for the build
18183 # platform. We can't use the AC_PROG_CC macro, since it can only be used
18184 # once. Also, we need to do this before adding a tools dir to the path,
18185 # otherwise we might pick up cross-compilers which don't use standard naming.
18186 # Otherwise, we'll set the BUILD_tools to the native tools, but that'll have
18187 # to wait until they are properly discovered.
18188 for ac_prog in cl cc gcc
18189 do
18190 # Extract the first word of "$ac_prog", so it can be a program name with args.
18191 set dummy $ac_prog; ac_word=$2
18192 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18193 $as_echo_n "checking for $ac_word... " >&6; }
18194 if ${ac_cv_path_BUILD_CC+:} false; then :
18195 $as_echo_n "(cached) " >&6
18196 else
18197 case $BUILD_CC in
18198 [\\/]* | ?:[\\/]*)
18199 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
18200 ;;
18201 *)
18202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18203 for as_dir in $PATH
18204 do
18205 IFS=$as_save_IFS
18206 test -z "$as_dir" && as_dir=.
18207 for ac_exec_ext in '' $ac_executable_extensions; do
18213 done
18214 done
18215 IFS=$as_save_IFS
18216
18217 ;;
18218 esac
18219 fi
18220 BUILD_CC=$ac_cv_path_BUILD_CC
18221 if test -n "$BUILD_CC"; then
18222 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
18223 $as_echo "$BUILD_CC" >&6; }
18224 else
18225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18226 $as_echo "no" >&6; }
18227 fi
18228
18229
18230 test -n "$BUILD_CC" && break
18231 done
18232
18233
18234 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18235
18236 # First separate the path from the arguments. This will split at the first
18237 # space.
18238 complete="$BUILD_CC"
18239 path="${complete%% *}"
18240 tmp="$complete EOL"
18241 arguments="${tmp#* }"
18242
18243 # Input might be given as Windows format, start by converting to
18244 # unix format.
18245 new_path=`$CYGPATH -u "$path"`
18246
18247 # Now try to locate executable using which
18248 new_path=`$WHICH "$new_path" 2> /dev/null`
18249 # bat and cmd files are not always considered executable in cygwin causing which
18250 # to not find them
18251 if test "x$new_path" = x \
18252 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18479 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18480 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18481 fi
18482 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
18483 fi
18484 fi
18485
18486 # Now join together the path and the arguments once again
18487 if test "x$arguments" != xEOL; then
18488 new_complete="$new_path ${arguments% *}"
18489 else
18490 new_complete="$new_path"
18491 fi
18492
18493 if test "x$complete" != "x$new_complete"; then
18494 BUILD_CC="$new_complete"
18495 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
18496 $as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
18497 fi
18498
18499 for ac_prog in cl CC g++
18500 do
18501 # Extract the first word of "$ac_prog", so it can be a program name with args.
18502 set dummy $ac_prog; ac_word=$2
18503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18504 $as_echo_n "checking for $ac_word... " >&6; }
18505 if ${ac_cv_path_BUILD_CXX+:} false; then :
18506 $as_echo_n "(cached) " >&6
18507 else
18508 case $BUILD_CXX in
18509 [\\/]* | ?:[\\/]*)
18510 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
18511 ;;
18512 *)
18513 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18514 for as_dir in $PATH
18515 do
18516 IFS=$as_save_IFS
18517 test -z "$as_dir" && as_dir=.
18518 for ac_exec_ext in '' $ac_executable_extensions; do
18524 done
18525 done
18526 IFS=$as_save_IFS
18527
18528 ;;
18529 esac
18530 fi
18531 BUILD_CXX=$ac_cv_path_BUILD_CXX
18532 if test -n "$BUILD_CXX"; then
18533 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
18534 $as_echo "$BUILD_CXX" >&6; }
18535 else
18536 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18537 $as_echo "no" >&6; }
18538 fi
18539
18540
18541 test -n "$BUILD_CXX" && break
18542 done
18543
18544
18545 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18546
18547 # First separate the path from the arguments. This will split at the first
18548 # space.
18549 complete="$BUILD_CXX"
18550 path="${complete%% *}"
18551 tmp="$complete EOL"
18552 arguments="${tmp#* }"
18553
18554 # Input might be given as Windows format, start by converting to
18555 # unix format.
18556 new_path=`$CYGPATH -u "$path"`
18557
18558 # Now try to locate executable using which
18559 new_path=`$WHICH "$new_path" 2> /dev/null`
18560 # bat and cmd files are not always considered executable in cygwin causing which
18561 # to not find them
18562 if test "x$new_path" = x \
18563 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18777 done
18778 IFS="$IFS_save"
18779 else
18780 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving BUILD_CXX (as $path) failed, using $path directly." >&5
18781 $as_echo "$as_me: Resolving BUILD_CXX (as $path) failed, using $path directly." >&6;}
18782 new_path="$path"
18783 fi
18784
18785 if test "x$new_path" = x; then
18786 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
18787 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
18788 has_space=`$ECHO "$complete" | $GREP " "`
18789 if test "x$has_space" != x; then
18790 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18791 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18792 fi
18793 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
18794 fi
18795 fi
18796
18797 # Now join together the path and the arguments once again
18798 if test "x$arguments" != xEOL; then
18799 new_complete="$new_path ${arguments% *}"
18800 else
18801 new_complete="$new_path"
18802 fi
18803
18804 if test "x$complete" != "x$new_complete"; then
18805 BUILD_CXX="$new_complete"
18806 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
18807 $as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
18808 fi
18809
18810 # Extract the first word of "ld", so it can be a program name with args.
18811 set dummy ld; ac_word=$2
18812 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18813 $as_echo_n "checking for $ac_word... " >&6; }
18814 if ${ac_cv_path_BUILD_LD+:} false; then :
18815 $as_echo_n "(cached) " >&6
18816 else
18817 case $BUILD_LD in
18818 [\\/]* | ?:[\\/]*)
18819 ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
18820 ;;
18821 *)
18822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18823 for as_dir in $PATH
18824 do
18825 IFS=$as_save_IFS
18826 test -z "$as_dir" && as_dir=.
18827 for ac_exec_ext in '' $ac_executable_extensions; do
18828 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18829 ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
18830 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18831 break 2
18832 fi
18833 done
18834 done
18835 IFS=$as_save_IFS
18836
18837 ;;
18838 esac
18839 fi
18840 BUILD_LD=$ac_cv_path_BUILD_LD
18841 if test -n "$BUILD_LD"; then
18842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
18843 $as_echo "$BUILD_LD" >&6; }
18844 else
18845 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18846 $as_echo "no" >&6; }
18847 fi
18848
18849
18850
18851 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18852
18853 # First separate the path from the arguments. This will split at the first
18854 # space.
18855 complete="$BUILD_LD"
18856 path="${complete%% *}"
18857 tmp="$complete EOL"
18858 arguments="${tmp#* }"
18859
18860 # Input might be given as Windows format, start by converting to
18861 # unix format.
18862 new_path=`$CYGPATH -u "$path"`
18863
18864 # Now try to locate executable using which
18865 new_path=`$WHICH "$new_path" 2> /dev/null`
18866 # bat and cmd files are not always considered executable in cygwin causing which
18867 # to not find them
18868 if test "x$new_path" = x \
18869 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
22826
22827 # Restore the flags to the user specified values.
22828 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
22829 CFLAGS="$ORG_CFLAGS"
22830 CXXFLAGS="$ORG_CXXFLAGS"
22831 OBJCFLAGS="$ORG_OBJCFLAGS"
22832
22833 LD="$CC"
22834 LDEXE="$CC"
22835 LDCXX="$CXX"
22836 LDEXECXX="$CXX"
22837
22838 # LDEXE is the linker to use, when creating executables.
22839
22840 # Linking C++ libraries.
22841
22842 # Linking C++ executables.
22843
22844
22845 if test "x$OPENJDK_TARGET_OS" != xwindows; then
22846 if test -n "$ac_tool_prefix"; then
22847 # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
22848 set dummy ${ac_tool_prefix}ar; ac_word=$2
22849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22850 $as_echo_n "checking for $ac_word... " >&6; }
22851 if ${ac_cv_prog_AR+:} false; then :
22852 $as_echo_n "(cached) " >&6
22853 else
22854 if test -n "$AR"; then
22855 ac_cv_prog_AR="$AR" # Let the user override the test.
22856 else
22857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22858 for as_dir in $PATH
22859 do
22860 IFS=$as_save_IFS
22861 test -z "$as_dir" && as_dir=.
22862 for ac_exec_ext in '' $ac_executable_extensions; do
22863 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22864 ac_cv_prog_AR="${ac_tool_prefix}ar"
22865 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22866 break 2
22867 fi
22868 done
22869 done
22870 IFS=$as_save_IFS
22871
22872 fi
22873 fi
22874 AR=$ac_cv_prog_AR
22875 if test -n "$AR"; then
22876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
22877 $as_echo "$AR" >&6; }
22878 else
22879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22880 $as_echo "no" >&6; }
22881 fi
22882
22883
22884 fi
22885 if test -z "$ac_cv_prog_AR"; then
22886 ac_ct_AR=$AR
22887 # Extract the first word of "ar", so it can be a program name with args.
22888 set dummy ar; ac_word=$2
22889 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22890 $as_echo_n "checking for $ac_word... " >&6; }
22891 if ${ac_cv_prog_ac_ct_AR+:} false; then :
22892 $as_echo_n "(cached) " >&6
22893 else
22894 if test -n "$ac_ct_AR"; then
22895 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
22896 else
22897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22898 for as_dir in $PATH
22899 do
22900 IFS=$as_save_IFS
22901 test -z "$as_dir" && as_dir=.
22902 for ac_exec_ext in '' $ac_executable_extensions; do
22903 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22904 ac_cv_prog_ac_ct_AR="ar"
22905 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22906 break 2
22907 fi
22908 done
22909 done
22910 IFS=$as_save_IFS
22911
22912 fi
22913 fi
22914 ac_ct_AR=$ac_cv_prog_ac_ct_AR
22915 if test -n "$ac_ct_AR"; then
22916 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
22917 $as_echo "$ac_ct_AR" >&6; }
22918 else
22919 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22920 $as_echo "no" >&6; }
22921 fi
22922
22923 if test "x$ac_ct_AR" = x; then
22924 AR=""
22925 else
22926 case $cross_compiling:$ac_tool_warned in
22927 yes:)
22928 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
22929 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
22930 ac_tool_warned=yes ;;
22931 esac
22932 AR=$ac_ct_AR
22933 fi
22934 else
22935 AR="$ac_cv_prog_AR"
22936 fi
22937
22938
22939 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22940
22941 # First separate the path from the arguments. This will split at the first
22942 # space.
22943 complete="$AR"
22944 path="${complete%% *}"
22945 tmp="$complete EOL"
22946 arguments="${tmp#* }"
22947
22948 # Input might be given as Windows format, start by converting to
22949 # unix format.
22950 new_path=`$CYGPATH -u "$path"`
22951
22952 # Now try to locate executable using which
22953 new_path=`$WHICH "$new_path" 2> /dev/null`
22954 # bat and cmd files are not always considered executable in cygwin causing which
22955 # to not find them
22956 if test "x$new_path" = x \
22957 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
22958 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
25707 # building the build platform executables. The cross-compilation
25708 # case needed to be done earlier, but this can only be done after
25709 # the native tools have been localized.
25710 BUILD_CC="$CC"
25711 BUILD_CXX="$CXX"
25712 BUILD_LD="$LD"
25713 fi
25714
25715 # for solaris we really need solaris tools, and not gnu equivalent
25716 # these seems to normally reside in /usr/ccs/bin so add that to path before
25717 # starting to probe
25718 #
25719 # NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH
25720 # so that it can be overriden --with-tools-dir
25721 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
25722 PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}"
25723 fi
25724
25725 # Find the right assembler.
25726 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
25727 # Extract the first word of "as", so it can be a program name with args.
25728 set dummy as; ac_word=$2
25729 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
25730 $as_echo_n "checking for $ac_word... " >&6; }
25731 if ${ac_cv_path_AS+:} false; then :
25732 $as_echo_n "(cached) " >&6
25733 else
25734 case $AS in
25735 [\\/]* | ?:[\\/]*)
25736 ac_cv_path_AS="$AS" # Let the user override the test with a path.
25737 ;;
25738 *)
25739 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
25740 for as_dir in $PATH
25741 do
25742 IFS=$as_save_IFS
25743 test -z "$as_dir" && as_dir=.
25744 for ac_exec_ext in '' $ac_executable_extensions; do
25745 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
25746 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
25747 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
25748 break 2
25749 fi
25750 done
25751 done
25752 IFS=$as_save_IFS
25753
25754 ;;
25755 esac
25756 fi
25757 AS=$ac_cv_path_AS
25758 if test -n "$AS"; then
25759 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
25760 $as_echo "$AS" >&6; }
25761 else
25762 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
25763 $as_echo "no" >&6; }
25764 fi
25765
25766
25767
25768 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25769
25770 # First separate the path from the arguments. This will split at the first
25771 # space.
25772 complete="$AS"
25773 path="${complete%% *}"
25774 tmp="$complete EOL"
25775 arguments="${tmp#* }"
25776
25777 # Input might be given as Windows format, start by converting to
25778 # unix format.
25779 new_path=`$CYGPATH -u "$path"`
25780
25781 # Now try to locate executable using which
25782 new_path=`$WHICH "$new_path" 2> /dev/null`
25783 # bat and cmd files are not always considered executable in cygwin causing which
25784 # to not find them
25785 if test "x$new_path" = x \
25786 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
26019
26020 # Now join together the path and the arguments once again
26021 if test "x$arguments" != xEOL; then
26022 new_complete="$new_path ${arguments% *}"
26023 else
26024 new_complete="$new_path"
26025 fi
26026
26027 if test "x$complete" != "x$new_complete"; then
26028 AS="$new_complete"
26029 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
26030 $as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
26031 fi
26032
26033 else
26034 AS="$CC -c"
26035 fi
26036
26037
26038 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
26039 # Extract the first word of "nm", so it can be a program name with args.
26040 set dummy nm; ac_word=$2
26041 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26042 $as_echo_n "checking for $ac_word... " >&6; }
26043 if ${ac_cv_path_NM+:} false; then :
26044 $as_echo_n "(cached) " >&6
26045 else
26046 case $NM in
26047 [\\/]* | ?:[\\/]*)
26048 ac_cv_path_NM="$NM" # Let the user override the test with a path.
26049 ;;
26050 *)
26051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26052 for as_dir in $PATH
26053 do
26054 IFS=$as_save_IFS
26055 test -z "$as_dir" && as_dir=.
26056 for ac_exec_ext in '' $ac_executable_extensions; do
26057 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26058 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
26059 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26060 break 2
26061 fi
26062 done
26063 done
26064 IFS=$as_save_IFS
26065
26066 ;;
26067 esac
26068 fi
26069 NM=$ac_cv_path_NM
26070 if test -n "$NM"; then
26071 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
26072 $as_echo "$NM" >&6; }
26073 else
26074 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26075 $as_echo "no" >&6; }
26076 fi
26077
26078
26079
26080 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26081
26082 # First separate the path from the arguments. This will split at the first
26083 # space.
26084 complete="$NM"
26085 path="${complete%% *}"
26086 tmp="$complete EOL"
26087 arguments="${tmp#* }"
26088
26089 # Input might be given as Windows format, start by converting to
26090 # unix format.
26091 new_path=`$CYGPATH -u "$path"`
26092
26093 # Now try to locate executable using which
26094 new_path=`$WHICH "$new_path" 2> /dev/null`
26095 # bat and cmd files are not always considered executable in cygwin causing which
26096 # to not find them
26097 if test "x$new_path" = x \
26098 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
26293 # We're on a posix platform. Hooray! :)
26294 # First separate the path from the arguments. This will split at the first
26295 # space.
26296 complete="$NM"
26297 path="${complete%% *}"
26298 tmp="$complete EOL"
26299 arguments="${tmp#* }"
26300
26301 # Cannot rely on the command "which" here since it doesn't always work.
26302 is_absolute_path=`$ECHO "$path" | $GREP ^/`
26303 if test -z "$is_absolute_path"; then
26304 # Path to executable is not absolute. Find it.
26305 IFS_save="$IFS"
26306 IFS=:
26307 for p in $PATH; do
26308 if test -f "$p/$path" && test -x "$p/$path"; then
26309 new_path="$p/$path"
26310 break
26311 fi
26312 done
26313 IFS="$IFS_save"
26314 else
26315 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving NM (as $path) failed, using $path directly." >&5
26316 $as_echo "$as_me: Resolving NM (as $path) failed, using $path directly." >&6;}
26317 new_path="$path"
26318 fi
26319
26320 if test "x$new_path" = x; then
26321 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
26322 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
26323 has_space=`$ECHO "$complete" | $GREP " "`
26324 if test "x$has_space" != x; then
26325 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
26326 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
26327 fi
26328 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
26329 fi
26330 fi
26331
26332 # Now join together the path and the arguments once again
26333 if test "x$arguments" != xEOL; then
26334 new_complete="$new_path ${arguments% *}"
26335 else
26336 new_complete="$new_path"
26337 fi
26338
26339 if test "x$complete" != "x$new_complete"; then
26340 NM="$new_complete"
26341 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
26342 $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
26343 fi
26344
26345 # Extract the first word of "gnm", so it can be a program name with args.
26346 set dummy gnm; ac_word=$2
26347 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26348 $as_echo_n "checking for $ac_word... " >&6; }
26349 if ${ac_cv_path_GNM+:} false; then :
26350 $as_echo_n "(cached) " >&6
26351 else
26352 case $GNM in
26353 [\\/]* | ?:[\\/]*)
26354 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
26355 ;;
26356 *)
26357 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26358 for as_dir in $PATH
26359 do
26360 IFS=$as_save_IFS
26361 test -z "$as_dir" && as_dir=.
26362 for ac_exec_ext in '' $ac_executable_extensions; do
26363 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26364 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
26365 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26366 break 2
26367 fi
26368 done
26369 done
26370 IFS=$as_save_IFS
26371
26372 ;;
26373 esac
26374 fi
26375 GNM=$ac_cv_path_GNM
26376 if test -n "$GNM"; then
26377 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
26378 $as_echo "$GNM" >&6; }
26379 else
26380 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26381 $as_echo "no" >&6; }
26382 fi
26383
26384
26385
26386 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26387
26388 # First separate the path from the arguments. This will split at the first
26389 # space.
26390 complete="$GNM"
26391 path="${complete%% *}"
26392 tmp="$complete EOL"
26393 arguments="${tmp#* }"
26394
26395 # Input might be given as Windows format, start by converting to
26396 # unix format.
26397 new_path=`$CYGPATH -u "$path"`
26398
26399 # Now try to locate executable using which
26400 new_path=`$WHICH "$new_path" 2> /dev/null`
26401 # bat and cmd files are not always considered executable in cygwin causing which
26402 # to not find them
26403 if test "x$new_path" = x \
26404 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
26631 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
26632 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
26633 fi
26634 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
26635 fi
26636 fi
26637
26638 # Now join together the path and the arguments once again
26639 if test "x$arguments" != xEOL; then
26640 new_complete="$new_path ${arguments% *}"
26641 else
26642 new_complete="$new_path"
26643 fi
26644
26645 if test "x$complete" != "x$new_complete"; then
26646 GNM="$new_complete"
26647 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
26648 $as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
26649 fi
26650
26651 # Extract the first word of "strip", so it can be a program name with args.
26652 set dummy strip; ac_word=$2
26653 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26654 $as_echo_n "checking for $ac_word... " >&6; }
26655 if ${ac_cv_path_STRIP+:} false; then :
26656 $as_echo_n "(cached) " >&6
26657 else
26658 case $STRIP in
26659 [\\/]* | ?:[\\/]*)
26660 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
26661 ;;
26662 *)
26663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26664 for as_dir in $PATH
26665 do
26666 IFS=$as_save_IFS
26667 test -z "$as_dir" && as_dir=.
26668 for ac_exec_ext in '' $ac_executable_extensions; do
26669 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26670 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
26671 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26672 break 2
26673 fi
26674 done
26675 done
26676 IFS=$as_save_IFS
26677
26678 ;;
26679 esac
26680 fi
26681 STRIP=$ac_cv_path_STRIP
26682 if test -n "$STRIP"; then
26683 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
26684 $as_echo "$STRIP" >&6; }
26685 else
26686 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26687 $as_echo "no" >&6; }
26688 fi
26689
26690
26691
26692 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26693
26694 # First separate the path from the arguments. This will split at the first
26695 # space.
26696 complete="$STRIP"
26697 path="${complete%% *}"
26698 tmp="$complete EOL"
26699 arguments="${tmp#* }"
26700
26701 # Input might be given as Windows format, start by converting to
26702 # unix format.
26703 new_path=`$CYGPATH -u "$path"`
26704
26705 # Now try to locate executable using which
26706 new_path=`$WHICH "$new_path" 2> /dev/null`
26707 # bat and cmd files are not always considered executable in cygwin causing which
26708 # to not find them
26709 if test "x$new_path" = x \
26710 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
26937 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
26938 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
26939 fi
26940 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
26941 fi
26942 fi
26943
26944 # Now join together the path and the arguments once again
26945 if test "x$arguments" != xEOL; then
26946 new_complete="$new_path ${arguments% *}"
26947 else
26948 new_complete="$new_path"
26949 fi
26950
26951 if test "x$complete" != "x$new_complete"; then
26952 STRIP="$new_complete"
26953 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
26954 $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
26955 fi
26956
26957 # Extract the first word of "mcs", so it can be a program name with args.
26958 set dummy mcs; ac_word=$2
26959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26960 $as_echo_n "checking for $ac_word... " >&6; }
26961 if ${ac_cv_path_MCS+:} false; then :
26962 $as_echo_n "(cached) " >&6
26963 else
26964 case $MCS in
26965 [\\/]* | ?:[\\/]*)
26966 ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
26967 ;;
26968 *)
26969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26970 for as_dir in $PATH
26971 do
26972 IFS=$as_save_IFS
26973 test -z "$as_dir" && as_dir=.
26974 for ac_exec_ext in '' $ac_executable_extensions; do
26975 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26976 ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
26977 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26978 break 2
26979 fi
26980 done
26981 done
26982 IFS=$as_save_IFS
26983
26984 ;;
26985 esac
26986 fi
26987 MCS=$ac_cv_path_MCS
26988 if test -n "$MCS"; then
26989 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
26990 $as_echo "$MCS" >&6; }
26991 else
26992 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26993 $as_echo "no" >&6; }
26994 fi
26995
26996
26997
26998 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26999
27000 # First separate the path from the arguments. This will split at the first
27001 # space.
27002 complete="$MCS"
27003 path="${complete%% *}"
27004 tmp="$complete EOL"
27005 arguments="${tmp#* }"
27006
27007 # Input might be given as Windows format, start by converting to
27008 # unix format.
27009 new_path=`$CYGPATH -u "$path"`
27010
27011 # Now try to locate executable using which
27012 new_path=`$WHICH "$new_path" 2> /dev/null`
27013 # bat and cmd files are not always considered executable in cygwin causing which
27014 # to not find them
27015 if test "x$new_path" = x \
27016 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
27287 done
27288 done
27289 IFS=$as_save_IFS
27290
27291 ;;
27292 esac
27293 fi
27294 OTOOL=$ac_cv_path_OTOOL
27295 if test -n "$OTOOL"; then
27296 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
27297 $as_echo "$OTOOL" >&6; }
27298 else
27299 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27300 $as_echo "no" >&6; }
27301 fi
27302
27303
27304 if test "x$OTOOL" = "x"; then
27305 OTOOL="true"
27306 fi
27307 if test -n "$ac_tool_prefix"; then
27308 # Extract the first word of "${ac_tool_prefix}nm", so it can be a program name with args.
27309 set dummy ${ac_tool_prefix}nm; ac_word=$2
27310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27311 $as_echo_n "checking for $ac_word... " >&6; }
27312 if ${ac_cv_prog_NM+:} false; then :
27313 $as_echo_n "(cached) " >&6
27314 else
27315 if test -n "$NM"; then
27316 ac_cv_prog_NM="$NM" # Let the user override the test.
27317 else
27318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27319 for as_dir in $PATH
27320 do
27321 IFS=$as_save_IFS
27322 test -z "$as_dir" && as_dir=.
27323 for ac_exec_ext in '' $ac_executable_extensions; do
27324 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27325 ac_cv_prog_NM="${ac_tool_prefix}nm"
27326 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27327 break 2
27328 fi
27329 done
27330 done
27331 IFS=$as_save_IFS
27332
27333 fi
27334 fi
27335 NM=$ac_cv_prog_NM
27336 if test -n "$NM"; then
27337 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
27338 $as_echo "$NM" >&6; }
27339 else
27340 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27341 $as_echo "no" >&6; }
27342 fi
27343
27344
27345 fi
27346 if test -z "$ac_cv_prog_NM"; then
27347 ac_ct_NM=$NM
27348 # Extract the first word of "nm", so it can be a program name with args.
27349 set dummy nm; ac_word=$2
27350 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27351 $as_echo_n "checking for $ac_word... " >&6; }
27352 if ${ac_cv_prog_ac_ct_NM+:} false; then :
27353 $as_echo_n "(cached) " >&6
27354 else
27355 if test -n "$ac_ct_NM"; then
27356 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
27357 else
27358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27359 for as_dir in $PATH
27360 do
27361 IFS=$as_save_IFS
27362 test -z "$as_dir" && as_dir=.
27363 for ac_exec_ext in '' $ac_executable_extensions; do
27364 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27365 ac_cv_prog_ac_ct_NM="nm"
27366 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27367 break 2
27368 fi
27369 done
27370 done
27371 IFS=$as_save_IFS
27372
27373 fi
27374 fi
27375 ac_ct_NM=$ac_cv_prog_ac_ct_NM
27376 if test -n "$ac_ct_NM"; then
27377 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
27378 $as_echo "$ac_ct_NM" >&6; }
27379 else
27380 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27381 $as_echo "no" >&6; }
27382 fi
27383
27384 if test "x$ac_ct_NM" = x; then
27385 NM=""
27386 else
27387 case $cross_compiling:$ac_tool_warned in
27388 yes:)
27389 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
27390 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
27391 ac_tool_warned=yes ;;
27392 esac
27393 NM=$ac_ct_NM
27394 fi
27395 else
27396 NM="$ac_cv_prog_NM"
27397 fi
27398
27399
27400 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27401
27402 # First separate the path from the arguments. This will split at the first
27403 # space.
27404 complete="$NM"
27405 path="${complete%% *}"
27406 tmp="$complete EOL"
27407 arguments="${tmp#* }"
27408
27409 # Input might be given as Windows format, start by converting to
27410 # unix format.
27411 new_path=`$CYGPATH -u "$path"`
27412
27413 # Now try to locate executable using which
27414 new_path=`$WHICH "$new_path" 2> /dev/null`
27415 # bat and cmd files are not always considered executable in cygwin causing which
27416 # to not find them
27417 if test "x$new_path" = x \
27418 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
27419 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
27632 done
27633 IFS="$IFS_save"
27634 else
27635 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving NM (as $path) failed, using $path directly." >&5
27636 $as_echo "$as_me: Resolving NM (as $path) failed, using $path directly." >&6;}
27637 new_path="$path"
27638 fi
27639
27640 if test "x$new_path" = x; then
27641 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
27642 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
27643 has_space=`$ECHO "$complete" | $GREP " "`
27644 if test "x$has_space" != x; then
27645 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
27646 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
27647 fi
27648 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
27649 fi
27650 fi
27651
27652 # Now join together the path and the arguments once again
27653 if test "x$arguments" != xEOL; then
27654 new_complete="$new_path ${arguments% *}"
27655 else
27656 new_complete="$new_path"
27657 fi
27658
27659 if test "x$complete" != "x$new_complete"; then
27660 NM="$new_complete"
27661 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
27662 $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
27663 fi
27664
27665 GNM="$NM"
27666
27667 if test -n "$ac_tool_prefix"; then
27668 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
27669 set dummy ${ac_tool_prefix}strip; ac_word=$2
27670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27671 $as_echo_n "checking for $ac_word... " >&6; }
27672 if ${ac_cv_prog_STRIP+:} false; then :
27673 $as_echo_n "(cached) " >&6
27674 else
27675 if test -n "$STRIP"; then
27676 ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
27677 else
27678 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27679 for as_dir in $PATH
27680 do
27681 IFS=$as_save_IFS
27682 test -z "$as_dir" && as_dir=.
27683 for ac_exec_ext in '' $ac_executable_extensions; do
27684 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27685 ac_cv_prog_STRIP="${ac_tool_prefix}strip"
27686 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27687 break 2
27688 fi
27689 done
27690 done
27691 IFS=$as_save_IFS
27692
27693 fi
27694 fi
27695 STRIP=$ac_cv_prog_STRIP
27696 if test -n "$STRIP"; then
27697 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
27698 $as_echo "$STRIP" >&6; }
27699 else
27700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27701 $as_echo "no" >&6; }
27702 fi
27703
27704
27705 fi
27706 if test -z "$ac_cv_prog_STRIP"; then
27707 ac_ct_STRIP=$STRIP
27708 # Extract the first word of "strip", so it can be a program name with args.
27709 set dummy strip; ac_word=$2
27710 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27711 $as_echo_n "checking for $ac_word... " >&6; }
27712 if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
27713 $as_echo_n "(cached) " >&6
27714 else
27715 if test -n "$ac_ct_STRIP"; then
27716 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
27717 else
27718 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27719 for as_dir in $PATH
27720 do
27721 IFS=$as_save_IFS
27722 test -z "$as_dir" && as_dir=.
27723 for ac_exec_ext in '' $ac_executable_extensions; do
27724 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27725 ac_cv_prog_ac_ct_STRIP="strip"
27726 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27727 break 2
27728 fi
27729 done
27730 done
27731 IFS=$as_save_IFS
27732
27733 fi
27734 fi
27735 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
27736 if test -n "$ac_ct_STRIP"; then
27737 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
27738 $as_echo "$ac_ct_STRIP" >&6; }
27739 else
27740 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27741 $as_echo "no" >&6; }
27742 fi
27743
27744 if test "x$ac_ct_STRIP" = x; then
27745 STRIP=""
27746 else
27747 case $cross_compiling:$ac_tool_warned in
27748 yes:)
27749 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
27750 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
27751 ac_tool_warned=yes ;;
27752 esac
27753 STRIP=$ac_ct_STRIP
27754 fi
27755 else
27756 STRIP="$ac_cv_prog_STRIP"
27757 fi
27758
27759
27760 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27761
27762 # First separate the path from the arguments. This will split at the first
27763 # space.
27764 complete="$STRIP"
27765 path="${complete%% *}"
27766 tmp="$complete EOL"
27767 arguments="${tmp#* }"
27768
27769 # Input might be given as Windows format, start by converting to
27770 # unix format.
27771 new_path=`$CYGPATH -u "$path"`
27772
27773 # Now try to locate executable using which
27774 new_path=`$WHICH "$new_path" 2> /dev/null`
27775 # bat and cmd files are not always considered executable in cygwin causing which
27776 # to not find them
27777 if test "x$new_path" = x \
27778 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
27779 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
28010 fi
28011
28012 # Now join together the path and the arguments once again
28013 if test "x$arguments" != xEOL; then
28014 new_complete="$new_path ${arguments% *}"
28015 else
28016 new_complete="$new_path"
28017 fi
28018
28019 if test "x$complete" != "x$new_complete"; then
28020 STRIP="$new_complete"
28021 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
28022 $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
28023 fi
28024
28025 fi
28026
28027 # objcopy is used for moving debug symbols to separate files when
28028 # full debug symbols are enabled.
28029 if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
28030 if test -n "$ac_tool_prefix"; then
28031 for ac_prog in gobjcopy objcopy
28032 do
28033 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
28034 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
28035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
28036 $as_echo_n "checking for $ac_word... " >&6; }
28037 if ${ac_cv_prog_OBJCOPY+:} false; then :
28038 $as_echo_n "(cached) " >&6
28039 else
28040 if test -n "$OBJCOPY"; then
28041 ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
28042 else
28043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
28044 for as_dir in $PATH
28045 do
28046 IFS=$as_save_IFS
28047 test -z "$as_dir" && as_dir=.
28048 for ac_exec_ext in '' $ac_executable_extensions; do
28049 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
28110 $as_echo "no" >&6; }
28111 fi
28112
28113
28114 test -n "$ac_ct_OBJCOPY" && break
28115 done
28116
28117 if test "x$ac_ct_OBJCOPY" = x; then
28118 OBJCOPY=""
28119 else
28120 case $cross_compiling:$ac_tool_warned in
28121 yes:)
28122 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
28123 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
28124 ac_tool_warned=yes ;;
28125 esac
28126 OBJCOPY=$ac_ct_OBJCOPY
28127 fi
28128 fi
28129
28130 # Only call fixup if objcopy was found.
28131 if test -n "$OBJCOPY"; then
28132
28133 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28134
28135 # First separate the path from the arguments. This will split at the first
28136 # space.
28137 complete="$OBJCOPY"
28138 path="${complete%% *}"
28139 tmp="$complete EOL"
28140 arguments="${tmp#* }"
28141
28142 # Input might be given as Windows format, start by converting to
28143 # unix format.
28144 new_path=`$CYGPATH -u "$path"`
28145
28146 # Now try to locate executable using which
28147 new_path=`$WHICH "$new_path" 2> /dev/null`
28148 # bat and cmd files are not always considered executable in cygwin causing which
28149 # to not find them
28381 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
28382 fi
28383 fi
28384
28385 # Now join together the path and the arguments once again
28386 if test "x$arguments" != xEOL; then
28387 new_complete="$new_path ${arguments% *}"
28388 else
28389 new_complete="$new_path"
28390 fi
28391
28392 if test "x$complete" != "x$new_complete"; then
28393 OBJCOPY="$new_complete"
28394 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
28395 $as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
28396 fi
28397
28398 fi
28399 fi
28400
28401 if test -n "$ac_tool_prefix"; then
28402 for ac_prog in gobjdump objdump
28403 do
28404 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
28405 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
28406 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
28407 $as_echo_n "checking for $ac_word... " >&6; }
28408 if ${ac_cv_prog_OBJDUMP+:} false; then :
28409 $as_echo_n "(cached) " >&6
28410 else
28411 if test -n "$OBJDUMP"; then
28412 ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
28413 else
28414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
28415 for as_dir in $PATH
28416 do
28417 IFS=$as_save_IFS
28418 test -z "$as_dir" && as_dir=.
28419 for ac_exec_ext in '' $ac_executable_extensions; do
28420 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
28481 $as_echo "no" >&6; }
28482 fi
28483
28484
28485 test -n "$ac_ct_OBJDUMP" && break
28486 done
28487
28488 if test "x$ac_ct_OBJDUMP" = x; then
28489 OBJDUMP=""
28490 else
28491 case $cross_compiling:$ac_tool_warned in
28492 yes:)
28493 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
28494 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
28495 ac_tool_warned=yes ;;
28496 esac
28497 OBJDUMP=$ac_ct_OBJDUMP
28498 fi
28499 fi
28500
28501 if test "x$OBJDUMP" != x; then
28502 # Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE bails if argument is missing.
28503
28504 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28505
28506 # First separate the path from the arguments. This will split at the first
28507 # space.
28508 complete="$OBJDUMP"
28509 path="${complete%% *}"
28510 tmp="$complete EOL"
28511 arguments="${tmp#* }"
28512
28513 # Input might be given as Windows format, start by converting to
28514 # unix format.
28515 new_path=`$CYGPATH -u "$path"`
28516
28517 # Now try to locate executable using which
28518 new_path=`$WHICH "$new_path" 2> /dev/null`
28519 # bat and cmd files are not always considered executable in cygwin causing which
28520 # to not find them
36391 # Setup use of ccache, if available
36392
36393 # Check whether --enable-ccache was given.
36394 if test "${enable_ccache+set}" = set; then :
36395 enableval=$enable_ccache;
36396 fi
36397
36398
36399 CCACHE=
36400 { $as_echo "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
36401 $as_echo_n "checking is ccache enabled... " >&6; }
36402 ENABLE_CCACHE=$enable_ccache
36403 if test "x$enable_ccache" = xyes; then
36404 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
36405 $as_echo "yes" >&6; }
36406 OLD_PATH="$PATH"
36407 if test "x$TOOLS_DIR" != x; then
36408 PATH=$TOOLS_DIR:$PATH
36409 fi
36410
36411 for ac_prog in ccache
36412 do
36413 # Extract the first word of "$ac_prog", so it can be a program name with args.
36414 set dummy $ac_prog; ac_word=$2
36415 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36416 $as_echo_n "checking for $ac_word... " >&6; }
36417 if ${ac_cv_path_CCACHE+:} false; then :
36418 $as_echo_n "(cached) " >&6
36419 else
36420 case $CCACHE in
36421 [\\/]* | ?:[\\/]*)
36422 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
36423 ;;
36424 *)
36425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36426 for as_dir in $PATH
36427 do
36428 IFS=$as_save_IFS
36429 test -z "$as_dir" && as_dir=.
36430 for ac_exec_ext in '' $ac_executable_extensions; do
36436 done
36437 done
36438 IFS=$as_save_IFS
36439
36440 ;;
36441 esac
36442 fi
36443 CCACHE=$ac_cv_path_CCACHE
36444 if test -n "$CCACHE"; then
36445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
36446 $as_echo "$CCACHE" >&6; }
36447 else
36448 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36449 $as_echo "no" >&6; }
36450 fi
36451
36452
36453 test -n "$CCACHE" && break
36454 done
36455
36456
36457 if test "x$CCACHE" = x; then
36458 if test "xccache" = x; then
36459 PROG_NAME=ccache
36460 else
36461 PROG_NAME=ccache
36462 fi
36463 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $PROG_NAME!" >&5
36464 $as_echo "$as_me: Could not find $PROG_NAME!" >&6;}
36465 as_fn_error $? "Cannot continue" "$LINENO" 5
36466 fi
36467
36468
36469 CCACHE_STATUS="enabled"
36470 PATH="$OLD_PATH"
36471 elif test "x$enable_ccache" = xno; then
36472 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
36473 $as_echo "no, explicitly disabled" >&6; }
36474 elif test "x$enable_ccache" = x; then
36475 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36476 $as_echo "no" >&6; }
36477 else
36478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
36479 $as_echo "unknown" >&6; }
36480 as_fn_error $? "--enable-ccache does not accept any parameters" "$LINENO" 5
36481 fi
36482
36483
36484
36485 # Check whether --with-ccache-dir was given.
36558 chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1
36559 fi
36560 fi
36561
36562 fi
36563
36564
36565 ###############################################################################
36566 #
36567 # And now the finish...
36568 #
36569 ###############################################################################
36570
36571 # Check for some common pitfalls
36572
36573 if test x"$OPENJDK_BUILD_OS" = xwindows; then
36574 file_to_test="$SRC_ROOT/LICENSE"
36575 if test `$STAT -c '%a' "$file_to_test"` -lt 400; then
36576 as_fn_error $? "Bad file permissions on src files. This is usually caused by cloning the repositories with a non cygwin hg in a directory not created in cygwin." "$LINENO" 5
36577 fi
36578 fi
36579
36580
36581 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
36582 $as_echo_n "checking if build directory is on local disk... " >&6; }
36583
36584 # df -l lists only local disks; if the given directory is not found then
36585 # a non-zero exit code is given
36586 if test "x$DF" = x; then
36587 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36588 # msys does not have df; use Windows "net use" instead.
36589 IS_NETWORK_DISK=`net use | grep \`pwd -W | cut -d ":" -f 1 | tr a-z A-Z\`:`
36590 if test "x$IS_NETWORK_DISK" = x; then
36591 OUTPUT_DIR_IS_LOCAL="yes"
36592 else
36593 OUTPUT_DIR_IS_LOCAL="no"
36594 fi
36595 else
36596 # No df here, say it's local
36597 OUTPUT_DIR_IS_LOCAL="yes"
|
701 SET_SHARED_LIBRARY_ORIGIN
702 CXX_FLAG_REORDER
703 C_FLAG_REORDER
704 SET_SHARED_LIBRARY_MAPFILE
705 SET_SHARED_LIBRARY_NAME
706 SHARED_LIBRARY_FLAGS
707 EXE_SUFFIX
708 STATIC_LIBRARY_SUFFIX
709 SHARED_LIBRARY_SUFFIX
710 LIBRARY_PREFIX
711 STATIC_LIBRARY
712 SHARED_LIBRARY
713 OBJ_SUFFIX
714 COMPILER_NAME
715 JT_HOME
716 JTREGEXE
717 ac_ct_OBJDUMP
718 OBJDUMP
719 ac_ct_OBJCOPY
720 OBJCOPY
721 ac_ct_STRIP
722 ac_ct_NM
723 OTOOL
724 MCS
725 STRIP
726 GNM
727 NM
728 AS
729 CXXCPP
730 CPP
731 COMPILER_TYPE
732 RC_FLAGS
733 DUMPBIN
734 WINAR
735 HOTSPOT_RC
736 HOTSPOT_MT
737 RC
738 MT
739 WINLD
740 HOTSPOT_LD
741 HOTSPOT_CXX
742 ARFLAGS
743 ac_ct_AR
744 AR
745 LDEXECXX
746 LDCXX
747 LDEXE
748 LD
749 ac_ct_OBJC
750 OBJCFLAGS
751 OBJC
752 CXX_VERSION
753 CC_VERSION
754 ac_ct_CXX
755 CXXFLAGS
756 CXX
757 ac_ct_PROPER_COMPILER_CXX
758 PROPER_COMPILER_CXX
759 POTENTIAL_CXX
760 TOOLS_DIR_CXX
761 COMPILER_TARGET_BITS_FLAG
762 OBJEXT
763 EXEEXT
911 OPENJDK_BUILD_OS_API
912 OPENJDK_BUILD_OS
913 OPENJDK_BUILD_AUTOCONF_NAME
914 OPENJDK_TARGET_AUTOCONF_NAME
915 target_os
916 target_vendor
917 target_cpu
918 target
919 host_os
920 host_vendor
921 host_cpu
922 host
923 build_os
924 build_vendor
925 build_cpu
926 build
927 SETFILE
928 DF
929 READLINK
930 CYGPATH
931 SED
932 FGREP
933 EGREP
934 GREP
935 AWK
936 XARGS
937 WHICH
938 WC
939 UNIQ
940 UNAME
941 TR
942 TOUCH
943 TEE
944 TAR
945 TAIL
946 SORT
947 SH
948 RM
949 PRINTF
950 NAWK
951 MV
952 MKTEMP
953 MKDIR
954 LS
955 LN
956 HEAD
957 FIND
958 FILE
959 EXPR
960 ECHO
961 DIRNAME
962 DIFF
963 DATE
964 CUT
965 CPIO
966 CP
967 COMM
968 CMP
969 CHMOD
970 CAT
1072 with_freetype_lib
1073 enable_freetype_bundling
1074 with_alsa
1075 with_alsa_include
1076 with_alsa_lib
1077 with_giflib
1078 with_zlib
1079 with_stdc__lib
1080 with_num_cores
1081 with_memory_size
1082 with_jobs
1083 with_sjavac_server_java
1084 enable_sjavac
1085 enable_precompiled_headers
1086 enable_ccache
1087 with_ccache_dir
1088 '
1089 ac_precious_vars='build_alias
1090 host_alias
1091 target_alias
1092 BASENAME
1093 BASH
1094 CAT
1095 CHMOD
1096 CMP
1097 COMM
1098 CP
1099 CPIO
1100 CUT
1101 DATE
1102 DIFF
1103 DIRNAME
1104 ECHO
1105 EXPR
1106 FILE
1107 FIND
1108 HEAD
1109 LN
1110 LS
1111 MKDIR
1112 MKTEMP
1113 MV
1114 NAWK
1115 PRINTF
1116 RM
1117 SH
1118 SORT
1119 TAIL
1120 TAR
1121 TEE
1122 TOUCH
1123 TR
1124 UNAME
1125 UNIQ
1126 WC
1127 WHICH
1128 XARGS
1129 AWK
1130 GREP
1131 EGREP
1132 FGREP
1133 SED
1134 CYGPATH
1135 READLINK
1136 DF
1137 SETFILE
1138 UNZIP
1139 ZIP
1140 LDD
1141 READELF
1142 HG
1143 STAT
1144 TIME
1145 DSYMUTIL
1146 XATTR
1147 CODESIGN
1148 PKG_CONFIG
1149 BUILD_CC
1150 BUILD_CXX
1151 BUILD_LD
1152 CC
1153 CFLAGS
1154 LDFLAGS
1155 LIBS
1156 CPPFLAGS
1157 CXX
1158 CXXFLAGS
1159 CCC
1160 OBJC
1161 OBJCFLAGS
1162 AR
1163 CPP
1164 CXXCPP
1165 AS
1166 NM
1167 GNM
1168 STRIP
1169 MCS
1170 OBJCOPY
1171 OBJDUMP
1172 JTREGEXE
1173 XMKMF
1174 FREETYPE_CFLAGS
1175 FREETYPE_LIBS
1176 ALSA_CFLAGS
1177 ALSA_LIBS
1178 LIBFFI_CFLAGS
1179 LIBFFI_LIBS
1180 CCACHE'
1181
1182
1183 # Initialize some variables set by options.
1184 ac_init_help=
1185 ac_init_version=false
1186 ac_unrecognized_opts=
1187 ac_unrecognized_sep=
1188 # The variables have the same names as the options, with
1189 # dashes changed to underlines.
1190 cache_file=/dev/null
1191 exec_prefix=NONE
1192 no_create=
1193 no_recursion=
1194 prefix=NONE
1195 program_prefix=NONE
1196 program_suffix=NONE
1197 program_transform_name=s,x,x,
1198 silent=
1199 site=
1200 srcdir=
1919 --with-giflib use giflib from build system or OpenJDK source
1920 (system, bundled) [bundled]
1921 --with-zlib use zlib from build system or OpenJDK source
1922 (system, bundled) [bundled]
1923 --with-stdc++lib=<static>,<dynamic>,<default>
1924 force linking of the C++ runtime on Linux to either
1925 static or dynamic, default is static with dynamic as
1926 fallback
1927 --with-num-cores number of cores in the build system, e.g.
1928 --with-num-cores=8 [probed]
1929 --with-memory-size memory (in MB) available in the build system, e.g.
1930 --with-memory-size=1024 [probed]
1931 --with-jobs number of parallel jobs to let make run [calculated
1932 based on cores and memory]
1933 --with-sjavac-server-java
1934 use this java binary for running the sjavac
1935 background server [Boot JDK java]
1936 --with-ccache-dir where to store ccache files [~/.ccache]
1937
1938 Some influential environment variables:
1939 BASENAME Override default value for BASENAME
1940 BASH Override default value for BASH
1941 CAT Override default value for CAT
1942 CHMOD Override default value for CHMOD
1943 CMP Override default value for CMP
1944 COMM Override default value for COMM
1945 CP Override default value for CP
1946 CPIO Override default value for CPIO
1947 CUT Override default value for CUT
1948 DATE Override default value for DATE
1949 DIFF Override default value for DIFF
1950 DIRNAME Override default value for DIRNAME
1951 ECHO Override default value for ECHO
1952 EXPR Override default value for EXPR
1953 FILE Override default value for FILE
1954 FIND Override default value for FIND
1955 HEAD Override default value for HEAD
1956 LN Override default value for LN
1957 LS Override default value for LS
1958 MKDIR Override default value for MKDIR
1959 MKTEMP Override default value for MKTEMP
1960 MV Override default value for MV
1961 NAWK Override default value for NAWK
1962 PRINTF Override default value for PRINTF
1963 RM Override default value for RM
1964 SH Override default value for SH
1965 SORT Override default value for SORT
1966 TAIL Override default value for TAIL
1967 TAR Override default value for TAR
1968 TEE Override default value for TEE
1969 TOUCH Override default value for TOUCH
1970 TR Override default value for TR
1971 UNAME Override default value for UNAME
1972 UNIQ Override default value for UNIQ
1973 WC Override default value for WC
1974 WHICH Override default value for WHICH
1975 XARGS Override default value for XARGS
1976 AWK Override default value for AWK
1977 GREP Override default value for GREP
1978 EGREP Override default value for EGREP
1979 FGREP Override default value for FGREP
1980 SED Override default value for SED
1981 CYGPATH Override default value for CYGPATH
1982 READLINK Override default value for READLINK
1983 DF Override default value for DF
1984 SETFILE Override default value for SETFILE
1985 UNZIP Override default value for UNZIP
1986 ZIP Override default value for ZIP
1987 LDD Override default value for LDD
1988 READELF Override default value for READELF
1989 HG Override default value for HG
1990 STAT Override default value for STAT
1991 TIME Override default value for TIME
1992 DSYMUTIL Override default value for DSYMUTIL
1993 XATTR Override default value for XATTR
1994 CODESIGN Override default value for CODESIGN
1995 PKG_CONFIG path to pkg-config utility
1996 BUILD_CC Override default value for BUILD_CC
1997 BUILD_CXX Override default value for BUILD_CXX
1998 BUILD_LD Override default value for BUILD_LD
1999 CC C compiler command
2000 CFLAGS C compiler flags
2001 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
2002 nonstandard directory <lib dir>
2003 LIBS libraries to pass to the linker, e.g. -l<library>
2004 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2005 you have headers in a nonstandard directory <include dir>
2006 CXX C++ compiler command
2007 CXXFLAGS C++ compiler flags
2008 OBJC Objective C compiler command
2009 OBJCFLAGS Objective C compiler flags
2010 AR Override default value for AR
2011 CPP C preprocessor
2012 CXXCPP C++ preprocessor
2013 AS Override default value for AS
2014 NM Override default value for NM
2015 GNM Override default value for GNM
2016 STRIP Override default value for STRIP
2017 MCS Override default value for MCS
2018 OBJCOPY Override default value for OBJCOPY
2019 OBJDUMP Override default value for OBJDUMP
2020 JTREGEXE Override default value for JTREGEXE
2021 XMKMF Path to xmkmf, Makefile generator for X Window System
2022 FREETYPE_CFLAGS
2023 C compiler flags for FREETYPE, overriding pkg-config
2024 FREETYPE_LIBS
2025 linker flags for FREETYPE, overriding pkg-config
2026 ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2027 ALSA_LIBS linker flags for ALSA, overriding pkg-config
2028 LIBFFI_CFLAGS
2029 C compiler flags for LIBFFI, overriding pkg-config
2030 LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2031 CCACHE Override default value for CCACHE
2032
2033 Use these variables to override the choices made by `configure' or to help
2034 it to find libraries and programs with nonstandard names/locations.
2035
2036 Report bugs to <build-dev@openjdk.java.net>.
2037 OpenJDK home page: <http://openjdk.java.net>.
2038 _ACEOF
2039 ac_status=$?
2040 fi
2041
2042 if test "$ac_init_help" = "recursive"; then
2043 # If there are subdirs, report their specific --help.
2044 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2045 test -d "$ac_dir" ||
2046 { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2047 continue
2048 ac_builddir=.
2049
2050 case "$ac_dir" in
2051 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
3314 # If the input variable does not have a directory specification, then
3315 # it need to be in the PATH.
3316 # $1: The name of the variable to fix
3317
3318
3319
3320
3321 # Register a --with argument but mark it as deprecated
3322 # $1: The name of the with argument to deprecate, not including --with-
3323
3324
3325 # Register a --enable argument but mark it as deprecated
3326 # $1: The name of the with argument to deprecate, not including --enable-
3327 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3328
3329
3330
3331
3332 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3333 # $1: variable to check
3334
3335
3336 # Check that there are no unprocessed overridden variables left.
3337 # If so, they are an incorrect argument and we will exit with an error.
3338
3339
3340 # Setup a tool for the given variable. If correctly specified by the user,
3341 # use that value, otherwise search for the tool using the supplied code snippet.
3342 # $1: variable to set
3343 # $2: code snippet to call to look for the tool
3344
3345
3346 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3347 # $1: variable to set
3348 # $2: executable name (or list of names) to look for
3349
3350
3351 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3352 # $1: variable to set
3353 # $2: executable name (or list of names) to look for
3354
3355
3356 # Like BASIC_PATH_PROGS but fails if no tool was found.
3357 # $1: variable to set
3358 # $2: executable name (or list of names) to look for
3359
3360
3361 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3362 # $1: variable to set
3363 # $2: autoconf macro to call to look for the special tool
3364
3365
3366 # Setup the most fundamental tools that relies on not much else to set up,
3367 # but is used by much of the early bootstrap code.
3368
3369
3370 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3371
3372
3373
3374
3375
3376
3377
3378 #%%% Simple tools %%%
3379
3380 # Check if we have found a usable version of make
3381 # $1: the path to a potential make binary (or empty)
3382 # $2: the description on how we found this
3383
4059 # Check if the VS env variables were setup prior to running configure.
4060 # If not, then find vcvarsall.bat and run it automatically, and integrate
4061 # the set env variables into the spec file.
4062
4063
4064
4065
4066
4067
4068
4069
4070
4071
4072
4073 # This line needs to be here, verbatim, after all includes and the dummy hook
4074 # definitions. It is replaced with custom functionality when building
4075 # custom sources.
4076 #CUSTOM_AUTOCONF_INCLUDE
4077
4078 # Do not change or remove the following line, it is needed for consistency checks:
4079 DATE_WHEN_GENERATED=1521554908
4080
4081 ###############################################################################
4082 #
4083 # Initialization / Boot-strapping
4084 #
4085 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4086 # thus it jumps back and forth, each time gaining something needed later on.
4087 #
4088 ###############################################################################
4089
4090 # Basic initialization that must happen first of all
4091
4092 # Save the original command line. This is passed to us by the wrapper configure script.
4093
4094 DATE_WHEN_CONFIGURED=`LANG=C date`
4095
4096 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4097 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4098 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4099 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4100
4101
4102 # Start with tools that do not need have cross compilation support
4103 # and can be expected to be found in the default PATH. These tools are
4104 # used by configure. Nor are these tools expected to be found in the
4105 # devkit from the builddeps server either, since they are
4106 # needed to download the devkit.
4107
4108 # First are all the simple required tools.
4109
4110
4111
4112 # Publish this variable in the help.
4113
4114
4115 if test "x$BASENAME" = x; then
4116 # The variable is not set by user, try to locate tool using the code snippet
4117 for ac_prog in basename
4118 do
4119 # Extract the first word of "$ac_prog", so it can be a program name with args.
4120 set dummy $ac_prog; ac_word=$2
4121 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4122 $as_echo_n "checking for $ac_word... " >&6; }
4123 if ${ac_cv_path_BASENAME+:} false; then :
4124 $as_echo_n "(cached) " >&6
4125 else
4126 case $BASENAME in
4127 [\\/]* | ?:[\\/]*)
4128 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4129 ;;
4130 *)
4131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4132 for as_dir in $PATH
4133 do
4134 IFS=$as_save_IFS
4135 test -z "$as_dir" && as_dir=.
4136 for ac_exec_ext in '' $ac_executable_extensions; do
4142 done
4143 done
4144 IFS=$as_save_IFS
4145
4146 ;;
4147 esac
4148 fi
4149 BASENAME=$ac_cv_path_BASENAME
4150 if test -n "$BASENAME"; then
4151 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4152 $as_echo "$BASENAME" >&6; }
4153 else
4154 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4155 $as_echo "no" >&6; }
4156 fi
4157
4158
4159 test -n "$BASENAME" && break
4160 done
4161
4162 else
4163 # The variable is set, but is it from the command line or the environment?
4164
4165 # Try to remove the string !BASENAME! from our list.
4166 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4167 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4168 # If it failed, the variable was not from the command line. Ignore it,
4169 # but warn the user (except for BASH, which is always set by the calling BASH).
4170 if test "xBASENAME" != xBASH; then
4171 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4172 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4173 fi
4174 # Try to locate tool using the code snippet
4175 for ac_prog in basename
4176 do
4177 # Extract the first word of "$ac_prog", so it can be a program name with args.
4178 set dummy $ac_prog; ac_word=$2
4179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4180 $as_echo_n "checking for $ac_word... " >&6; }
4181 if ${ac_cv_path_BASENAME+:} false; then :
4182 $as_echo_n "(cached) " >&6
4183 else
4184 case $BASENAME in
4185 [\\/]* | ?:[\\/]*)
4186 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4187 ;;
4188 *)
4189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4190 for as_dir in $PATH
4191 do
4192 IFS=$as_save_IFS
4193 test -z "$as_dir" && as_dir=.
4194 for ac_exec_ext in '' $ac_executable_extensions; do
4195 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4196 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4197 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4198 break 2
4199 fi
4200 done
4201 done
4202 IFS=$as_save_IFS
4203
4204 ;;
4205 esac
4206 fi
4207 BASENAME=$ac_cv_path_BASENAME
4208 if test -n "$BASENAME"; then
4209 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4210 $as_echo "$BASENAME" >&6; }
4211 else
4212 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4213 $as_echo "no" >&6; }
4214 fi
4215
4216
4217 test -n "$BASENAME" && break
4218 done
4219
4220 else
4221 # If it succeeded, then it was overridden by the user. We will use it
4222 # for the tool.
4223
4224 # First remove it from the list of overridden variables, so we can test
4225 # for unknown variables in the end.
4226 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4227
4228 # Check if the provided tool contains a complete path.
4229 tool_specified="$BASENAME"
4230 tool_basename="${tool_specified##*/}"
4231 if test "x$tool_basename" = "x$tool_specified"; then
4232 # A command without a complete path is provided, search $PATH.
4233 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4234 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4235 # Extract the first word of "$tool_basename", so it can be a program name with args.
4236 set dummy $tool_basename; ac_word=$2
4237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4238 $as_echo_n "checking for $ac_word... " >&6; }
4239 if ${ac_cv_path_BASENAME+:} false; then :
4240 $as_echo_n "(cached) " >&6
4241 else
4242 case $BASENAME in
4243 [\\/]* | ?:[\\/]*)
4244 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4245 ;;
4246 *)
4247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4248 for as_dir in $PATH
4249 do
4250 IFS=$as_save_IFS
4251 test -z "$as_dir" && as_dir=.
4252 for ac_exec_ext in '' $ac_executable_extensions; do
4253 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4254 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4255 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4256 break 2
4257 fi
4258 done
4259 done
4260 IFS=$as_save_IFS
4261
4262 ;;
4263 esac
4264 fi
4265 BASENAME=$ac_cv_path_BASENAME
4266 if test -n "$BASENAME"; then
4267 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4268 $as_echo "$BASENAME" >&6; }
4269 else
4270 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4271 $as_echo "no" >&6; }
4272 fi
4273
4274
4275 if test "x$BASENAME" = x; then
4276 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4277 fi
4278 else
4279 # Otherwise we believe it is a complete path. Use it as it is.
4280 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4281 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4282 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4283 $as_echo_n "checking for BASENAME... " >&6; }
4284 if test ! -x "$tool_specified"; then
4285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4286 $as_echo "not found" >&6; }
4287 as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4288 fi
4289 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4290 $as_echo "$tool_specified" >&6; }
4291 fi
4292 fi
4293 fi
4294
4295
4296
4297 if test "x$BASENAME" = x; then
4298 as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4299 fi
4300
4301
4302
4303
4304
4305 # Publish this variable in the help.
4306
4307
4308 if test "x$BASH" = x; then
4309 # The variable is not set by user, try to locate tool using the code snippet
4310 for ac_prog in bash
4311 do
4312 # Extract the first word of "$ac_prog", so it can be a program name with args.
4313 set dummy $ac_prog; ac_word=$2
4314 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4315 $as_echo_n "checking for $ac_word... " >&6; }
4316 if ${ac_cv_path_BASH+:} false; then :
4317 $as_echo_n "(cached) " >&6
4318 else
4319 case $BASH in
4320 [\\/]* | ?:[\\/]*)
4321 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4322 ;;
4323 *)
4324 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4325 for as_dir in $PATH
4326 do
4327 IFS=$as_save_IFS
4328 test -z "$as_dir" && as_dir=.
4329 for ac_exec_ext in '' $ac_executable_extensions; do
4330 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4331 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4332 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4333 break 2
4334 fi
4335 done
4336 done
4337 IFS=$as_save_IFS
4338
4339 ;;
4340 esac
4341 fi
4342 BASH=$ac_cv_path_BASH
4343 if test -n "$BASH"; then
4344 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4345 $as_echo "$BASH" >&6; }
4346 else
4347 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4348 $as_echo "no" >&6; }
4349 fi
4350
4351
4352 test -n "$BASH" && break
4353 done
4354
4355 else
4356 # The variable is set, but is it from the command line or the environment?
4357
4358 # Try to remove the string !BASH! from our list.
4359 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4360 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4361 # If it failed, the variable was not from the command line. Ignore it,
4362 # but warn the user (except for BASH, which is always set by the calling BASH).
4363 if test "xBASH" != xBASH; then
4364 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4365 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4366 fi
4367 # Try to locate tool using the code snippet
4368 for ac_prog in bash
4369 do
4370 # Extract the first word of "$ac_prog", so it can be a program name with args.
4371 set dummy $ac_prog; ac_word=$2
4372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4373 $as_echo_n "checking for $ac_word... " >&6; }
4374 if ${ac_cv_path_BASH+:} false; then :
4375 $as_echo_n "(cached) " >&6
4376 else
4377 case $BASH in
4378 [\\/]* | ?:[\\/]*)
4379 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4380 ;;
4381 *)
4382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4383 for as_dir in $PATH
4384 do
4385 IFS=$as_save_IFS
4386 test -z "$as_dir" && as_dir=.
4387 for ac_exec_ext in '' $ac_executable_extensions; do
4388 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4389 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4390 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4391 break 2
4392 fi
4393 done
4394 done
4395 IFS=$as_save_IFS
4396
4397 ;;
4398 esac
4399 fi
4400 BASH=$ac_cv_path_BASH
4401 if test -n "$BASH"; then
4402 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4403 $as_echo "$BASH" >&6; }
4404 else
4405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4406 $as_echo "no" >&6; }
4407 fi
4408
4409
4410 test -n "$BASH" && break
4411 done
4412
4413 else
4414 # If it succeeded, then it was overridden by the user. We will use it
4415 # for the tool.
4416
4417 # First remove it from the list of overridden variables, so we can test
4418 # for unknown variables in the end.
4419 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4420
4421 # Check if the provided tool contains a complete path.
4422 tool_specified="$BASH"
4423 tool_basename="${tool_specified##*/}"
4424 if test "x$tool_basename" = "x$tool_specified"; then
4425 # A command without a complete path is provided, search $PATH.
4426 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4427 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4428 # Extract the first word of "$tool_basename", so it can be a program name with args.
4429 set dummy $tool_basename; ac_word=$2
4430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4431 $as_echo_n "checking for $ac_word... " >&6; }
4432 if ${ac_cv_path_BASH+:} false; then :
4433 $as_echo_n "(cached) " >&6
4434 else
4435 case $BASH in
4436 [\\/]* | ?:[\\/]*)
4437 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4438 ;;
4439 *)
4440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4441 for as_dir in $PATH
4442 do
4443 IFS=$as_save_IFS
4444 test -z "$as_dir" && as_dir=.
4445 for ac_exec_ext in '' $ac_executable_extensions; do
4446 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4447 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4448 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4449 break 2
4450 fi
4451 done
4452 done
4453 IFS=$as_save_IFS
4454
4455 ;;
4456 esac
4457 fi
4458 BASH=$ac_cv_path_BASH
4459 if test -n "$BASH"; then
4460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4461 $as_echo "$BASH" >&6; }
4462 else
4463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4464 $as_echo "no" >&6; }
4465 fi
4466
4467
4468 if test "x$BASH" = x; then
4469 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4470 fi
4471 else
4472 # Otherwise we believe it is a complete path. Use it as it is.
4473 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4474 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4475 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4476 $as_echo_n "checking for BASH... " >&6; }
4477 if test ! -x "$tool_specified"; then
4478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4479 $as_echo "not found" >&6; }
4480 as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4481 fi
4482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4483 $as_echo "$tool_specified" >&6; }
4484 fi
4485 fi
4486 fi
4487
4488
4489
4490 if test "x$BASH" = x; then
4491 as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4492 fi
4493
4494
4495
4496
4497
4498 # Publish this variable in the help.
4499
4500
4501 if test "x$CAT" = x; then
4502 # The variable is not set by user, try to locate tool using the code snippet
4503 for ac_prog in cat
4504 do
4505 # Extract the first word of "$ac_prog", so it can be a program name with args.
4506 set dummy $ac_prog; ac_word=$2
4507 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4508 $as_echo_n "checking for $ac_word... " >&6; }
4509 if ${ac_cv_path_CAT+:} false; then :
4510 $as_echo_n "(cached) " >&6
4511 else
4512 case $CAT in
4513 [\\/]* | ?:[\\/]*)
4514 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4515 ;;
4516 *)
4517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4518 for as_dir in $PATH
4519 do
4520 IFS=$as_save_IFS
4521 test -z "$as_dir" && as_dir=.
4522 for ac_exec_ext in '' $ac_executable_extensions; do
4523 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4524 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4525 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4526 break 2
4527 fi
4528 done
4529 done
4530 IFS=$as_save_IFS
4531
4532 ;;
4533 esac
4534 fi
4535 CAT=$ac_cv_path_CAT
4536 if test -n "$CAT"; then
4537 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4538 $as_echo "$CAT" >&6; }
4539 else
4540 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4541 $as_echo "no" >&6; }
4542 fi
4543
4544
4545 test -n "$CAT" && break
4546 done
4547
4548 else
4549 # The variable is set, but is it from the command line or the environment?
4550
4551 # Try to remove the string !CAT! from our list.
4552 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4553 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4554 # If it failed, the variable was not from the command line. Ignore it,
4555 # but warn the user (except for BASH, which is always set by the calling BASH).
4556 if test "xCAT" != xBASH; then
4557 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4558 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4559 fi
4560 # Try to locate tool using the code snippet
4561 for ac_prog in cat
4562 do
4563 # Extract the first word of "$ac_prog", so it can be a program name with args.
4564 set dummy $ac_prog; ac_word=$2
4565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4566 $as_echo_n "checking for $ac_word... " >&6; }
4567 if ${ac_cv_path_CAT+:} false; then :
4568 $as_echo_n "(cached) " >&6
4569 else
4570 case $CAT in
4571 [\\/]* | ?:[\\/]*)
4572 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4573 ;;
4574 *)
4575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4576 for as_dir in $PATH
4577 do
4578 IFS=$as_save_IFS
4579 test -z "$as_dir" && as_dir=.
4580 for ac_exec_ext in '' $ac_executable_extensions; do
4581 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4582 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4583 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4584 break 2
4585 fi
4586 done
4587 done
4588 IFS=$as_save_IFS
4589
4590 ;;
4591 esac
4592 fi
4593 CAT=$ac_cv_path_CAT
4594 if test -n "$CAT"; then
4595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4596 $as_echo "$CAT" >&6; }
4597 else
4598 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4599 $as_echo "no" >&6; }
4600 fi
4601
4602
4603 test -n "$CAT" && break
4604 done
4605
4606 else
4607 # If it succeeded, then it was overridden by the user. We will use it
4608 # for the tool.
4609
4610 # First remove it from the list of overridden variables, so we can test
4611 # for unknown variables in the end.
4612 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4613
4614 # Check if the provided tool contains a complete path.
4615 tool_specified="$CAT"
4616 tool_basename="${tool_specified##*/}"
4617 if test "x$tool_basename" = "x$tool_specified"; then
4618 # A command without a complete path is provided, search $PATH.
4619 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4620 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4621 # Extract the first word of "$tool_basename", so it can be a program name with args.
4622 set dummy $tool_basename; ac_word=$2
4623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4624 $as_echo_n "checking for $ac_word... " >&6; }
4625 if ${ac_cv_path_CAT+:} false; then :
4626 $as_echo_n "(cached) " >&6
4627 else
4628 case $CAT in
4629 [\\/]* | ?:[\\/]*)
4630 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4631 ;;
4632 *)
4633 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4634 for as_dir in $PATH
4635 do
4636 IFS=$as_save_IFS
4637 test -z "$as_dir" && as_dir=.
4638 for ac_exec_ext in '' $ac_executable_extensions; do
4639 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4640 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4641 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4642 break 2
4643 fi
4644 done
4645 done
4646 IFS=$as_save_IFS
4647
4648 ;;
4649 esac
4650 fi
4651 CAT=$ac_cv_path_CAT
4652 if test -n "$CAT"; then
4653 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4654 $as_echo "$CAT" >&6; }
4655 else
4656 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4657 $as_echo "no" >&6; }
4658 fi
4659
4660
4661 if test "x$CAT" = x; then
4662 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4663 fi
4664 else
4665 # Otherwise we believe it is a complete path. Use it as it is.
4666 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4667 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4668 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4669 $as_echo_n "checking for CAT... " >&6; }
4670 if test ! -x "$tool_specified"; then
4671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4672 $as_echo "not found" >&6; }
4673 as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4674 fi
4675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4676 $as_echo "$tool_specified" >&6; }
4677 fi
4678 fi
4679 fi
4680
4681
4682
4683 if test "x$CAT" = x; then
4684 as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4685 fi
4686
4687
4688
4689
4690
4691 # Publish this variable in the help.
4692
4693
4694 if test "x$CHMOD" = x; then
4695 # The variable is not set by user, try to locate tool using the code snippet
4696 for ac_prog in chmod
4697 do
4698 # Extract the first word of "$ac_prog", so it can be a program name with args.
4699 set dummy $ac_prog; ac_word=$2
4700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4701 $as_echo_n "checking for $ac_word... " >&6; }
4702 if ${ac_cv_path_CHMOD+:} false; then :
4703 $as_echo_n "(cached) " >&6
4704 else
4705 case $CHMOD in
4706 [\\/]* | ?:[\\/]*)
4707 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4708 ;;
4709 *)
4710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4711 for as_dir in $PATH
4712 do
4713 IFS=$as_save_IFS
4714 test -z "$as_dir" && as_dir=.
4715 for ac_exec_ext in '' $ac_executable_extensions; do
4716 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4717 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4718 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4719 break 2
4720 fi
4721 done
4722 done
4723 IFS=$as_save_IFS
4724
4725 ;;
4726 esac
4727 fi
4728 CHMOD=$ac_cv_path_CHMOD
4729 if test -n "$CHMOD"; then
4730 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4731 $as_echo "$CHMOD" >&6; }
4732 else
4733 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4734 $as_echo "no" >&6; }
4735 fi
4736
4737
4738 test -n "$CHMOD" && break
4739 done
4740
4741 else
4742 # The variable is set, but is it from the command line or the environment?
4743
4744 # Try to remove the string !CHMOD! from our list.
4745 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
4746 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4747 # If it failed, the variable was not from the command line. Ignore it,
4748 # but warn the user (except for BASH, which is always set by the calling BASH).
4749 if test "xCHMOD" != xBASH; then
4750 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
4751 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
4752 fi
4753 # Try to locate tool using the code snippet
4754 for ac_prog in chmod
4755 do
4756 # Extract the first word of "$ac_prog", so it can be a program name with args.
4757 set dummy $ac_prog; ac_word=$2
4758 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4759 $as_echo_n "checking for $ac_word... " >&6; }
4760 if ${ac_cv_path_CHMOD+:} false; then :
4761 $as_echo_n "(cached) " >&6
4762 else
4763 case $CHMOD in
4764 [\\/]* | ?:[\\/]*)
4765 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4766 ;;
4767 *)
4768 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4769 for as_dir in $PATH
4770 do
4771 IFS=$as_save_IFS
4772 test -z "$as_dir" && as_dir=.
4773 for ac_exec_ext in '' $ac_executable_extensions; do
4774 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4775 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4776 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4777 break 2
4778 fi
4779 done
4780 done
4781 IFS=$as_save_IFS
4782
4783 ;;
4784 esac
4785 fi
4786 CHMOD=$ac_cv_path_CHMOD
4787 if test -n "$CHMOD"; then
4788 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4789 $as_echo "$CHMOD" >&6; }
4790 else
4791 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4792 $as_echo "no" >&6; }
4793 fi
4794
4795
4796 test -n "$CHMOD" && break
4797 done
4798
4799 else
4800 # If it succeeded, then it was overridden by the user. We will use it
4801 # for the tool.
4802
4803 # First remove it from the list of overridden variables, so we can test
4804 # for unknown variables in the end.
4805 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4806
4807 # Check if the provided tool contains a complete path.
4808 tool_specified="$CHMOD"
4809 tool_basename="${tool_specified##*/}"
4810 if test "x$tool_basename" = "x$tool_specified"; then
4811 # A command without a complete path is provided, search $PATH.
4812 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
4813 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
4814 # Extract the first word of "$tool_basename", so it can be a program name with args.
4815 set dummy $tool_basename; ac_word=$2
4816 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4817 $as_echo_n "checking for $ac_word... " >&6; }
4818 if ${ac_cv_path_CHMOD+:} false; then :
4819 $as_echo_n "(cached) " >&6
4820 else
4821 case $CHMOD in
4822 [\\/]* | ?:[\\/]*)
4823 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4824 ;;
4825 *)
4826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4827 for as_dir in $PATH
4828 do
4829 IFS=$as_save_IFS
4830 test -z "$as_dir" && as_dir=.
4831 for ac_exec_ext in '' $ac_executable_extensions; do
4832 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4833 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4834 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4835 break 2
4836 fi
4837 done
4838 done
4839 IFS=$as_save_IFS
4840
4841 ;;
4842 esac
4843 fi
4844 CHMOD=$ac_cv_path_CHMOD
4845 if test -n "$CHMOD"; then
4846 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4847 $as_echo "$CHMOD" >&6; }
4848 else
4849 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4850 $as_echo "no" >&6; }
4851 fi
4852
4853
4854 if test "x$CHMOD" = x; then
4855 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4856 fi
4857 else
4858 # Otherwise we believe it is a complete path. Use it as it is.
4859 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
4860 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
4861 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
4862 $as_echo_n "checking for CHMOD... " >&6; }
4863 if test ! -x "$tool_specified"; then
4864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4865 $as_echo "not found" >&6; }
4866 as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
4867 fi
4868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4869 $as_echo "$tool_specified" >&6; }
4870 fi
4871 fi
4872 fi
4873
4874
4875
4876 if test "x$CHMOD" = x; then
4877 as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
4878 fi
4879
4880
4881
4882
4883
4884 # Publish this variable in the help.
4885
4886
4887 if test "x$CMP" = x; then
4888 # The variable is not set by user, try to locate tool using the code snippet
4889 for ac_prog in cmp
4890 do
4891 # Extract the first word of "$ac_prog", so it can be a program name with args.
4892 set dummy $ac_prog; ac_word=$2
4893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4894 $as_echo_n "checking for $ac_word... " >&6; }
4895 if ${ac_cv_path_CMP+:} false; then :
4896 $as_echo_n "(cached) " >&6
4897 else
4898 case $CMP in
4899 [\\/]* | ?:[\\/]*)
4900 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
4901 ;;
4902 *)
4903 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4904 for as_dir in $PATH
4905 do
4906 IFS=$as_save_IFS
4907 test -z "$as_dir" && as_dir=.
4908 for ac_exec_ext in '' $ac_executable_extensions; do
4909 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4910 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
4911 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4912 break 2
4913 fi
4914 done
4915 done
4916 IFS=$as_save_IFS
4917
4918 ;;
4919 esac
4920 fi
4921 CMP=$ac_cv_path_CMP
4922 if test -n "$CMP"; then
4923 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
4924 $as_echo "$CMP" >&6; }
4925 else
4926 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4927 $as_echo "no" >&6; }
4928 fi
4929
4930
4931 test -n "$CMP" && break
4932 done
4933
4934 else
4935 # The variable is set, but is it from the command line or the environment?
4936
4937 # Try to remove the string !CMP! from our list.
4938 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
4939 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4940 # If it failed, the variable was not from the command line. Ignore it,
4941 # but warn the user (except for BASH, which is always set by the calling BASH).
4942 if test "xCMP" != xBASH; then
4943 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
4944 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
4945 fi
4946 # Try to locate tool using the code snippet
4947 for ac_prog in cmp
4948 do
4949 # Extract the first word of "$ac_prog", so it can be a program name with args.
4950 set dummy $ac_prog; ac_word=$2
4951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4952 $as_echo_n "checking for $ac_word... " >&6; }
4953 if ${ac_cv_path_CMP+:} false; then :
4954 $as_echo_n "(cached) " >&6
4955 else
4956 case $CMP in
4957 [\\/]* | ?:[\\/]*)
4958 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
4959 ;;
4960 *)
4961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4962 for as_dir in $PATH
4963 do
4964 IFS=$as_save_IFS
4965 test -z "$as_dir" && as_dir=.
4966 for ac_exec_ext in '' $ac_executable_extensions; do
4967 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4968 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
4969 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4970 break 2
4971 fi
4972 done
4973 done
4974 IFS=$as_save_IFS
4975
4976 ;;
4977 esac
4978 fi
4979 CMP=$ac_cv_path_CMP
4980 if test -n "$CMP"; then
4981 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
4982 $as_echo "$CMP" >&6; }
4983 else
4984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4985 $as_echo "no" >&6; }
4986 fi
4987
4988
4989 test -n "$CMP" && break
4990 done
4991
4992 else
4993 # If it succeeded, then it was overridden by the user. We will use it
4994 # for the tool.
4995
4996 # First remove it from the list of overridden variables, so we can test
4997 # for unknown variables in the end.
4998 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4999
5000 # Check if the provided tool contains a complete path.
5001 tool_specified="$CMP"
5002 tool_basename="${tool_specified##*/}"
5003 if test "x$tool_basename" = "x$tool_specified"; then
5004 # A command without a complete path is provided, search $PATH.
5005 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5006 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5007 # Extract the first word of "$tool_basename", so it can be a program name with args.
5008 set dummy $tool_basename; ac_word=$2
5009 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5010 $as_echo_n "checking for $ac_word... " >&6; }
5011 if ${ac_cv_path_CMP+:} false; then :
5012 $as_echo_n "(cached) " >&6
5013 else
5014 case $CMP in
5015 [\\/]* | ?:[\\/]*)
5016 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5017 ;;
5018 *)
5019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5020 for as_dir in $PATH
5021 do
5022 IFS=$as_save_IFS
5023 test -z "$as_dir" && as_dir=.
5024 for ac_exec_ext in '' $ac_executable_extensions; do
5025 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5026 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5027 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5028 break 2
5029 fi
5030 done
5031 done
5032 IFS=$as_save_IFS
5033
5034 ;;
5035 esac
5036 fi
5037 CMP=$ac_cv_path_CMP
5038 if test -n "$CMP"; then
5039 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5040 $as_echo "$CMP" >&6; }
5041 else
5042 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5043 $as_echo "no" >&6; }
5044 fi
5045
5046
5047 if test "x$CMP" = x; then
5048 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5049 fi
5050 else
5051 # Otherwise we believe it is a complete path. Use it as it is.
5052 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5053 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5054 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5055 $as_echo_n "checking for CMP... " >&6; }
5056 if test ! -x "$tool_specified"; then
5057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5058 $as_echo "not found" >&6; }
5059 as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5060 fi
5061 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5062 $as_echo "$tool_specified" >&6; }
5063 fi
5064 fi
5065 fi
5066
5067
5068
5069 if test "x$CMP" = x; then
5070 as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5071 fi
5072
5073
5074
5075
5076
5077 # Publish this variable in the help.
5078
5079
5080 if test "x$COMM" = x; then
5081 # The variable is not set by user, try to locate tool using the code snippet
5082 for ac_prog in comm
5083 do
5084 # Extract the first word of "$ac_prog", so it can be a program name with args.
5085 set dummy $ac_prog; ac_word=$2
5086 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5087 $as_echo_n "checking for $ac_word... " >&6; }
5088 if ${ac_cv_path_COMM+:} false; then :
5089 $as_echo_n "(cached) " >&6
5090 else
5091 case $COMM in
5092 [\\/]* | ?:[\\/]*)
5093 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5094 ;;
5095 *)
5096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5097 for as_dir in $PATH
5098 do
5099 IFS=$as_save_IFS
5100 test -z "$as_dir" && as_dir=.
5101 for ac_exec_ext in '' $ac_executable_extensions; do
5102 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5103 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5104 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5105 break 2
5106 fi
5107 done
5108 done
5109 IFS=$as_save_IFS
5110
5111 ;;
5112 esac
5113 fi
5114 COMM=$ac_cv_path_COMM
5115 if test -n "$COMM"; then
5116 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5117 $as_echo "$COMM" >&6; }
5118 else
5119 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5120 $as_echo "no" >&6; }
5121 fi
5122
5123
5124 test -n "$COMM" && break
5125 done
5126
5127 else
5128 # The variable is set, but is it from the command line or the environment?
5129
5130 # Try to remove the string !COMM! from our list.
5131 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5132 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5133 # If it failed, the variable was not from the command line. Ignore it,
5134 # but warn the user (except for BASH, which is always set by the calling BASH).
5135 if test "xCOMM" != xBASH; then
5136 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5137 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5138 fi
5139 # Try to locate tool using the code snippet
5140 for ac_prog in comm
5141 do
5142 # Extract the first word of "$ac_prog", so it can be a program name with args.
5143 set dummy $ac_prog; ac_word=$2
5144 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5145 $as_echo_n "checking for $ac_word... " >&6; }
5146 if ${ac_cv_path_COMM+:} false; then :
5147 $as_echo_n "(cached) " >&6
5148 else
5149 case $COMM in
5150 [\\/]* | ?:[\\/]*)
5151 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5152 ;;
5153 *)
5154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5155 for as_dir in $PATH
5156 do
5157 IFS=$as_save_IFS
5158 test -z "$as_dir" && as_dir=.
5159 for ac_exec_ext in '' $ac_executable_extensions; do
5160 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5161 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5162 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5163 break 2
5164 fi
5165 done
5166 done
5167 IFS=$as_save_IFS
5168
5169 ;;
5170 esac
5171 fi
5172 COMM=$ac_cv_path_COMM
5173 if test -n "$COMM"; then
5174 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5175 $as_echo "$COMM" >&6; }
5176 else
5177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5178 $as_echo "no" >&6; }
5179 fi
5180
5181
5182 test -n "$COMM" && break
5183 done
5184
5185 else
5186 # If it succeeded, then it was overridden by the user. We will use it
5187 # for the tool.
5188
5189 # First remove it from the list of overridden variables, so we can test
5190 # for unknown variables in the end.
5191 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5192
5193 # Check if the provided tool contains a complete path.
5194 tool_specified="$COMM"
5195 tool_basename="${tool_specified##*/}"
5196 if test "x$tool_basename" = "x$tool_specified"; then
5197 # A command without a complete path is provided, search $PATH.
5198 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5199 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5200 # Extract the first word of "$tool_basename", so it can be a program name with args.
5201 set dummy $tool_basename; ac_word=$2
5202 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5203 $as_echo_n "checking for $ac_word... " >&6; }
5204 if ${ac_cv_path_COMM+:} false; then :
5205 $as_echo_n "(cached) " >&6
5206 else
5207 case $COMM in
5208 [\\/]* | ?:[\\/]*)
5209 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5210 ;;
5211 *)
5212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5213 for as_dir in $PATH
5214 do
5215 IFS=$as_save_IFS
5216 test -z "$as_dir" && as_dir=.
5217 for ac_exec_ext in '' $ac_executable_extensions; do
5218 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5219 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5220 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5221 break 2
5222 fi
5223 done
5224 done
5225 IFS=$as_save_IFS
5226
5227 ;;
5228 esac
5229 fi
5230 COMM=$ac_cv_path_COMM
5231 if test -n "$COMM"; then
5232 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5233 $as_echo "$COMM" >&6; }
5234 else
5235 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5236 $as_echo "no" >&6; }
5237 fi
5238
5239
5240 if test "x$COMM" = x; then
5241 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5242 fi
5243 else
5244 # Otherwise we believe it is a complete path. Use it as it is.
5245 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5246 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5247 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5248 $as_echo_n "checking for COMM... " >&6; }
5249 if test ! -x "$tool_specified"; then
5250 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5251 $as_echo "not found" >&6; }
5252 as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5253 fi
5254 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5255 $as_echo "$tool_specified" >&6; }
5256 fi
5257 fi
5258 fi
5259
5260
5261
5262 if test "x$COMM" = x; then
5263 as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5264 fi
5265
5266
5267
5268
5269
5270 # Publish this variable in the help.
5271
5272
5273 if test "x$CP" = x; then
5274 # The variable is not set by user, try to locate tool using the code snippet
5275 for ac_prog in cp
5276 do
5277 # Extract the first word of "$ac_prog", so it can be a program name with args.
5278 set dummy $ac_prog; ac_word=$2
5279 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5280 $as_echo_n "checking for $ac_word... " >&6; }
5281 if ${ac_cv_path_CP+:} false; then :
5282 $as_echo_n "(cached) " >&6
5283 else
5284 case $CP in
5285 [\\/]* | ?:[\\/]*)
5286 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5287 ;;
5288 *)
5289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5290 for as_dir in $PATH
5291 do
5292 IFS=$as_save_IFS
5293 test -z "$as_dir" && as_dir=.
5294 for ac_exec_ext in '' $ac_executable_extensions; do
5295 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5296 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5297 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5298 break 2
5299 fi
5300 done
5301 done
5302 IFS=$as_save_IFS
5303
5304 ;;
5305 esac
5306 fi
5307 CP=$ac_cv_path_CP
5308 if test -n "$CP"; then
5309 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5310 $as_echo "$CP" >&6; }
5311 else
5312 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5313 $as_echo "no" >&6; }
5314 fi
5315
5316
5317 test -n "$CP" && break
5318 done
5319
5320 else
5321 # The variable is set, but is it from the command line or the environment?
5322
5323 # Try to remove the string !CP! from our list.
5324 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5325 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5326 # If it failed, the variable was not from the command line. Ignore it,
5327 # but warn the user (except for BASH, which is always set by the calling BASH).
5328 if test "xCP" != xBASH; then
5329 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5330 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5331 fi
5332 # Try to locate tool using the code snippet
5333 for ac_prog in cp
5334 do
5335 # Extract the first word of "$ac_prog", so it can be a program name with args.
5336 set dummy $ac_prog; ac_word=$2
5337 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5338 $as_echo_n "checking for $ac_word... " >&6; }
5339 if ${ac_cv_path_CP+:} false; then :
5340 $as_echo_n "(cached) " >&6
5341 else
5342 case $CP in
5343 [\\/]* | ?:[\\/]*)
5344 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5345 ;;
5346 *)
5347 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5348 for as_dir in $PATH
5349 do
5350 IFS=$as_save_IFS
5351 test -z "$as_dir" && as_dir=.
5352 for ac_exec_ext in '' $ac_executable_extensions; do
5353 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5354 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5355 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5356 break 2
5357 fi
5358 done
5359 done
5360 IFS=$as_save_IFS
5361
5362 ;;
5363 esac
5364 fi
5365 CP=$ac_cv_path_CP
5366 if test -n "$CP"; then
5367 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5368 $as_echo "$CP" >&6; }
5369 else
5370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5371 $as_echo "no" >&6; }
5372 fi
5373
5374
5375 test -n "$CP" && break
5376 done
5377
5378 else
5379 # If it succeeded, then it was overridden by the user. We will use it
5380 # for the tool.
5381
5382 # First remove it from the list of overridden variables, so we can test
5383 # for unknown variables in the end.
5384 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5385
5386 # Check if the provided tool contains a complete path.
5387 tool_specified="$CP"
5388 tool_basename="${tool_specified##*/}"
5389 if test "x$tool_basename" = "x$tool_specified"; then
5390 # A command without a complete path is provided, search $PATH.
5391 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5392 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5393 # Extract the first word of "$tool_basename", so it can be a program name with args.
5394 set dummy $tool_basename; ac_word=$2
5395 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5396 $as_echo_n "checking for $ac_word... " >&6; }
5397 if ${ac_cv_path_CP+:} false; then :
5398 $as_echo_n "(cached) " >&6
5399 else
5400 case $CP in
5401 [\\/]* | ?:[\\/]*)
5402 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5403 ;;
5404 *)
5405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5406 for as_dir in $PATH
5407 do
5408 IFS=$as_save_IFS
5409 test -z "$as_dir" && as_dir=.
5410 for ac_exec_ext in '' $ac_executable_extensions; do
5411 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5412 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5413 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5414 break 2
5415 fi
5416 done
5417 done
5418 IFS=$as_save_IFS
5419
5420 ;;
5421 esac
5422 fi
5423 CP=$ac_cv_path_CP
5424 if test -n "$CP"; then
5425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5426 $as_echo "$CP" >&6; }
5427 else
5428 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5429 $as_echo "no" >&6; }
5430 fi
5431
5432
5433 if test "x$CP" = x; then
5434 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5435 fi
5436 else
5437 # Otherwise we believe it is a complete path. Use it as it is.
5438 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5439 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5440 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5441 $as_echo_n "checking for CP... " >&6; }
5442 if test ! -x "$tool_specified"; then
5443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5444 $as_echo "not found" >&6; }
5445 as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5446 fi
5447 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5448 $as_echo "$tool_specified" >&6; }
5449 fi
5450 fi
5451 fi
5452
5453
5454
5455 if test "x$CP" = x; then
5456 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5457 fi
5458
5459
5460
5461
5462
5463 # Publish this variable in the help.
5464
5465
5466 if test "x$CPIO" = x; then
5467 # The variable is not set by user, try to locate tool using the code snippet
5468 for ac_prog in cpio
5469 do
5470 # Extract the first word of "$ac_prog", so it can be a program name with args.
5471 set dummy $ac_prog; ac_word=$2
5472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5473 $as_echo_n "checking for $ac_word... " >&6; }
5474 if ${ac_cv_path_CPIO+:} false; then :
5475 $as_echo_n "(cached) " >&6
5476 else
5477 case $CPIO in
5478 [\\/]* | ?:[\\/]*)
5479 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5480 ;;
5481 *)
5482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5483 for as_dir in $PATH
5484 do
5485 IFS=$as_save_IFS
5486 test -z "$as_dir" && as_dir=.
5487 for ac_exec_ext in '' $ac_executable_extensions; do
5488 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5489 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5490 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5491 break 2
5492 fi
5493 done
5494 done
5495 IFS=$as_save_IFS
5496
5497 ;;
5498 esac
5499 fi
5500 CPIO=$ac_cv_path_CPIO
5501 if test -n "$CPIO"; then
5502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5503 $as_echo "$CPIO" >&6; }
5504 else
5505 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5506 $as_echo "no" >&6; }
5507 fi
5508
5509
5510 test -n "$CPIO" && break
5511 done
5512
5513 else
5514 # The variable is set, but is it from the command line or the environment?
5515
5516 # Try to remove the string !CPIO! from our list.
5517 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
5518 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5519 # If it failed, the variable was not from the command line. Ignore it,
5520 # but warn the user (except for BASH, which is always set by the calling BASH).
5521 if test "xCPIO" != xBASH; then
5522 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
5523 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
5524 fi
5525 # Try to locate tool using the code snippet
5526 for ac_prog in cpio
5527 do
5528 # Extract the first word of "$ac_prog", so it can be a program name with args.
5529 set dummy $ac_prog; ac_word=$2
5530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5531 $as_echo_n "checking for $ac_word... " >&6; }
5532 if ${ac_cv_path_CPIO+:} false; then :
5533 $as_echo_n "(cached) " >&6
5534 else
5535 case $CPIO in
5536 [\\/]* | ?:[\\/]*)
5537 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5538 ;;
5539 *)
5540 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5541 for as_dir in $PATH
5542 do
5543 IFS=$as_save_IFS
5544 test -z "$as_dir" && as_dir=.
5545 for ac_exec_ext in '' $ac_executable_extensions; do
5546 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5547 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5548 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5549 break 2
5550 fi
5551 done
5552 done
5553 IFS=$as_save_IFS
5554
5555 ;;
5556 esac
5557 fi
5558 CPIO=$ac_cv_path_CPIO
5559 if test -n "$CPIO"; then
5560 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5561 $as_echo "$CPIO" >&6; }
5562 else
5563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5564 $as_echo "no" >&6; }
5565 fi
5566
5567
5568 test -n "$CPIO" && break
5569 done
5570
5571 else
5572 # If it succeeded, then it was overridden by the user. We will use it
5573 # for the tool.
5574
5575 # First remove it from the list of overridden variables, so we can test
5576 # for unknown variables in the end.
5577 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5578
5579 # Check if the provided tool contains a complete path.
5580 tool_specified="$CPIO"
5581 tool_basename="${tool_specified##*/}"
5582 if test "x$tool_basename" = "x$tool_specified"; then
5583 # A command without a complete path is provided, search $PATH.
5584 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
5585 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
5586 # Extract the first word of "$tool_basename", so it can be a program name with args.
5587 set dummy $tool_basename; ac_word=$2
5588 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5589 $as_echo_n "checking for $ac_word... " >&6; }
5590 if ${ac_cv_path_CPIO+:} false; then :
5591 $as_echo_n "(cached) " >&6
5592 else
5593 case $CPIO in
5594 [\\/]* | ?:[\\/]*)
5595 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5596 ;;
5597 *)
5598 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5599 for as_dir in $PATH
5600 do
5601 IFS=$as_save_IFS
5602 test -z "$as_dir" && as_dir=.
5603 for ac_exec_ext in '' $ac_executable_extensions; do
5604 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5605 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5606 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5607 break 2
5608 fi
5609 done
5610 done
5611 IFS=$as_save_IFS
5612
5613 ;;
5614 esac
5615 fi
5616 CPIO=$ac_cv_path_CPIO
5617 if test -n "$CPIO"; then
5618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5619 $as_echo "$CPIO" >&6; }
5620 else
5621 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5622 $as_echo "no" >&6; }
5623 fi
5624
5625
5626 if test "x$CPIO" = x; then
5627 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5628 fi
5629 else
5630 # Otherwise we believe it is a complete path. Use it as it is.
5631 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
5632 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
5633 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
5634 $as_echo_n "checking for CPIO... " >&6; }
5635 if test ! -x "$tool_specified"; then
5636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5637 $as_echo "not found" >&6; }
5638 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
5639 fi
5640 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5641 $as_echo "$tool_specified" >&6; }
5642 fi
5643 fi
5644 fi
5645
5646
5647
5648 if test "x$CPIO" = x; then
5649 as_fn_error $? "Could not find required tool for CPIO" "$LINENO" 5
5650 fi
5651
5652
5653
5654
5655
5656 # Publish this variable in the help.
5657
5658
5659 if test "x$CUT" = x; then
5660 # The variable is not set by user, try to locate tool using the code snippet
5661 for ac_prog in cut
5662 do
5663 # Extract the first word of "$ac_prog", so it can be a program name with args.
5664 set dummy $ac_prog; ac_word=$2
5665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5666 $as_echo_n "checking for $ac_word... " >&6; }
5667 if ${ac_cv_path_CUT+:} false; then :
5668 $as_echo_n "(cached) " >&6
5669 else
5670 case $CUT in
5671 [\\/]* | ?:[\\/]*)
5672 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5673 ;;
5674 *)
5675 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5676 for as_dir in $PATH
5677 do
5678 IFS=$as_save_IFS
5679 test -z "$as_dir" && as_dir=.
5680 for ac_exec_ext in '' $ac_executable_extensions; do
5681 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5682 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5683 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5684 break 2
5685 fi
5686 done
5687 done
5688 IFS=$as_save_IFS
5689
5690 ;;
5691 esac
5692 fi
5693 CUT=$ac_cv_path_CUT
5694 if test -n "$CUT"; then
5695 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5696 $as_echo "$CUT" >&6; }
5697 else
5698 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5699 $as_echo "no" >&6; }
5700 fi
5701
5702
5703 test -n "$CUT" && break
5704 done
5705
5706 else
5707 # The variable is set, but is it from the command line or the environment?
5708
5709 # Try to remove the string !CUT! from our list.
5710 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5711 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5712 # If it failed, the variable was not from the command line. Ignore it,
5713 # but warn the user (except for BASH, which is always set by the calling BASH).
5714 if test "xCUT" != xBASH; then
5715 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5716 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5717 fi
5718 # Try to locate tool using the code snippet
5719 for ac_prog in cut
5720 do
5721 # Extract the first word of "$ac_prog", so it can be a program name with args.
5722 set dummy $ac_prog; ac_word=$2
5723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5724 $as_echo_n "checking for $ac_word... " >&6; }
5725 if ${ac_cv_path_CUT+:} false; then :
5726 $as_echo_n "(cached) " >&6
5727 else
5728 case $CUT in
5729 [\\/]* | ?:[\\/]*)
5730 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5731 ;;
5732 *)
5733 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5734 for as_dir in $PATH
5735 do
5736 IFS=$as_save_IFS
5737 test -z "$as_dir" && as_dir=.
5738 for ac_exec_ext in '' $ac_executable_extensions; do
5739 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5740 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5741 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5742 break 2
5743 fi
5744 done
5745 done
5746 IFS=$as_save_IFS
5747
5748 ;;
5749 esac
5750 fi
5751 CUT=$ac_cv_path_CUT
5752 if test -n "$CUT"; then
5753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5754 $as_echo "$CUT" >&6; }
5755 else
5756 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5757 $as_echo "no" >&6; }
5758 fi
5759
5760
5761 test -n "$CUT" && break
5762 done
5763
5764 else
5765 # If it succeeded, then it was overridden by the user. We will use it
5766 # for the tool.
5767
5768 # First remove it from the list of overridden variables, so we can test
5769 # for unknown variables in the end.
5770 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5771
5772 # Check if the provided tool contains a complete path.
5773 tool_specified="$CUT"
5774 tool_basename="${tool_specified##*/}"
5775 if test "x$tool_basename" = "x$tool_specified"; then
5776 # A command without a complete path is provided, search $PATH.
5777 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5778 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5779 # Extract the first word of "$tool_basename", so it can be a program name with args.
5780 set dummy $tool_basename; ac_word=$2
5781 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5782 $as_echo_n "checking for $ac_word... " >&6; }
5783 if ${ac_cv_path_CUT+:} false; then :
5784 $as_echo_n "(cached) " >&6
5785 else
5786 case $CUT in
5787 [\\/]* | ?:[\\/]*)
5788 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5789 ;;
5790 *)
5791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5792 for as_dir in $PATH
5793 do
5794 IFS=$as_save_IFS
5795 test -z "$as_dir" && as_dir=.
5796 for ac_exec_ext in '' $ac_executable_extensions; do
5797 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5798 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5799 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5800 break 2
5801 fi
5802 done
5803 done
5804 IFS=$as_save_IFS
5805
5806 ;;
5807 esac
5808 fi
5809 CUT=$ac_cv_path_CUT
5810 if test -n "$CUT"; then
5811 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5812 $as_echo "$CUT" >&6; }
5813 else
5814 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5815 $as_echo "no" >&6; }
5816 fi
5817
5818
5819 if test "x$CUT" = x; then
5820 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5821 fi
5822 else
5823 # Otherwise we believe it is a complete path. Use it as it is.
5824 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5825 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5826 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5827 $as_echo_n "checking for CUT... " >&6; }
5828 if test ! -x "$tool_specified"; then
5829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5830 $as_echo "not found" >&6; }
5831 as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5832 fi
5833 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5834 $as_echo "$tool_specified" >&6; }
5835 fi
5836 fi
5837 fi
5838
5839
5840
5841 if test "x$CUT" = x; then
5842 as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5843 fi
5844
5845
5846
5847
5848
5849 # Publish this variable in the help.
5850
5851
5852 if test "x$DATE" = x; then
5853 # The variable is not set by user, try to locate tool using the code snippet
5854 for ac_prog in date
5855 do
5856 # Extract the first word of "$ac_prog", so it can be a program name with args.
5857 set dummy $ac_prog; ac_word=$2
5858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5859 $as_echo_n "checking for $ac_word... " >&6; }
5860 if ${ac_cv_path_DATE+:} false; then :
5861 $as_echo_n "(cached) " >&6
5862 else
5863 case $DATE in
5864 [\\/]* | ?:[\\/]*)
5865 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5866 ;;
5867 *)
5868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5869 for as_dir in $PATH
5870 do
5871 IFS=$as_save_IFS
5872 test -z "$as_dir" && as_dir=.
5873 for ac_exec_ext in '' $ac_executable_extensions; do
5874 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5875 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5876 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5877 break 2
5878 fi
5879 done
5880 done
5881 IFS=$as_save_IFS
5882
5883 ;;
5884 esac
5885 fi
5886 DATE=$ac_cv_path_DATE
5887 if test -n "$DATE"; then
5888 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5889 $as_echo "$DATE" >&6; }
5890 else
5891 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5892 $as_echo "no" >&6; }
5893 fi
5894
5895
5896 test -n "$DATE" && break
5897 done
5898
5899 else
5900 # The variable is set, but is it from the command line or the environment?
5901
5902 # Try to remove the string !DATE! from our list.
5903 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
5904 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5905 # If it failed, the variable was not from the command line. Ignore it,
5906 # but warn the user (except for BASH, which is always set by the calling BASH).
5907 if test "xDATE" != xBASH; then
5908 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
5909 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
5910 fi
5911 # Try to locate tool using the code snippet
5912 for ac_prog in date
5913 do
5914 # Extract the first word of "$ac_prog", so it can be a program name with args.
5915 set dummy $ac_prog; ac_word=$2
5916 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5917 $as_echo_n "checking for $ac_word... " >&6; }
5918 if ${ac_cv_path_DATE+:} false; then :
5919 $as_echo_n "(cached) " >&6
5920 else
5921 case $DATE in
5922 [\\/]* | ?:[\\/]*)
5923 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5924 ;;
5925 *)
5926 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5927 for as_dir in $PATH
5928 do
5929 IFS=$as_save_IFS
5930 test -z "$as_dir" && as_dir=.
5931 for ac_exec_ext in '' $ac_executable_extensions; do
5932 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5933 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5934 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5935 break 2
5936 fi
5937 done
5938 done
5939 IFS=$as_save_IFS
5940
5941 ;;
5942 esac
5943 fi
5944 DATE=$ac_cv_path_DATE
5945 if test -n "$DATE"; then
5946 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5947 $as_echo "$DATE" >&6; }
5948 else
5949 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5950 $as_echo "no" >&6; }
5951 fi
5952
5953
5954 test -n "$DATE" && break
5955 done
5956
5957 else
5958 # If it succeeded, then it was overridden by the user. We will use it
5959 # for the tool.
5960
5961 # First remove it from the list of overridden variables, so we can test
5962 # for unknown variables in the end.
5963 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5964
5965 # Check if the provided tool contains a complete path.
5966 tool_specified="$DATE"
5967 tool_basename="${tool_specified##*/}"
5968 if test "x$tool_basename" = "x$tool_specified"; then
5969 # A command without a complete path is provided, search $PATH.
5970 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
5971 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
5972 # Extract the first word of "$tool_basename", so it can be a program name with args.
5973 set dummy $tool_basename; ac_word=$2
5974 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5975 $as_echo_n "checking for $ac_word... " >&6; }
5976 if ${ac_cv_path_DATE+:} false; then :
5977 $as_echo_n "(cached) " >&6
5978 else
5979 case $DATE in
5980 [\\/]* | ?:[\\/]*)
5981 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5982 ;;
5983 *)
5984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5985 for as_dir in $PATH
5986 do
5987 IFS=$as_save_IFS
5988 test -z "$as_dir" && as_dir=.
5989 for ac_exec_ext in '' $ac_executable_extensions; do
5990 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5991 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5992 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5993 break 2
5994 fi
5995 done
5996 done
5997 IFS=$as_save_IFS
5998
5999 ;;
6000 esac
6001 fi
6002 DATE=$ac_cv_path_DATE
6003 if test -n "$DATE"; then
6004 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6005 $as_echo "$DATE" >&6; }
6006 else
6007 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6008 $as_echo "no" >&6; }
6009 fi
6010
6011
6012 if test "x$DATE" = x; then
6013 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6014 fi
6015 else
6016 # Otherwise we believe it is a complete path. Use it as it is.
6017 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6018 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6019 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6020 $as_echo_n "checking for DATE... " >&6; }
6021 if test ! -x "$tool_specified"; then
6022 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6023 $as_echo "not found" >&6; }
6024 as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6025 fi
6026 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6027 $as_echo "$tool_specified" >&6; }
6028 fi
6029 fi
6030 fi
6031
6032
6033
6034 if test "x$DATE" = x; then
6035 as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6036 fi
6037
6038
6039
6040
6041
6042 # Publish this variable in the help.
6043
6044
6045 if test "x$DIFF" = x; then
6046 # The variable is not set by user, try to locate tool using the code snippet
6047 for ac_prog in gdiff diff
6048 do
6049 # Extract the first word of "$ac_prog", so it can be a program name with args.
6050 set dummy $ac_prog; ac_word=$2
6051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6052 $as_echo_n "checking for $ac_word... " >&6; }
6053 if ${ac_cv_path_DIFF+:} false; then :
6054 $as_echo_n "(cached) " >&6
6055 else
6056 case $DIFF in
6057 [\\/]* | ?:[\\/]*)
6058 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6059 ;;
6060 *)
6061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6062 for as_dir in $PATH
6063 do
6064 IFS=$as_save_IFS
6065 test -z "$as_dir" && as_dir=.
6066 for ac_exec_ext in '' $ac_executable_extensions; do
6067 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6068 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6069 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6070 break 2
6071 fi
6072 done
6073 done
6074 IFS=$as_save_IFS
6075
6076 ;;
6077 esac
6078 fi
6079 DIFF=$ac_cv_path_DIFF
6080 if test -n "$DIFF"; then
6081 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6082 $as_echo "$DIFF" >&6; }
6083 else
6084 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6085 $as_echo "no" >&6; }
6086 fi
6087
6088
6089 test -n "$DIFF" && break
6090 done
6091
6092 else
6093 # The variable is set, but is it from the command line or the environment?
6094
6095 # Try to remove the string !DIFF! from our list.
6096 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6097 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6098 # If it failed, the variable was not from the command line. Ignore it,
6099 # but warn the user (except for BASH, which is always set by the calling BASH).
6100 if test "xDIFF" != xBASH; then
6101 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6102 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6103 fi
6104 # Try to locate tool using the code snippet
6105 for ac_prog in gdiff diff
6106 do
6107 # Extract the first word of "$ac_prog", so it can be a program name with args.
6108 set dummy $ac_prog; ac_word=$2
6109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6110 $as_echo_n "checking for $ac_word... " >&6; }
6111 if ${ac_cv_path_DIFF+:} false; then :
6112 $as_echo_n "(cached) " >&6
6113 else
6114 case $DIFF in
6115 [\\/]* | ?:[\\/]*)
6116 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6117 ;;
6118 *)
6119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6120 for as_dir in $PATH
6121 do
6122 IFS=$as_save_IFS
6123 test -z "$as_dir" && as_dir=.
6124 for ac_exec_ext in '' $ac_executable_extensions; do
6125 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6126 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6127 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6128 break 2
6129 fi
6130 done
6131 done
6132 IFS=$as_save_IFS
6133
6134 ;;
6135 esac
6136 fi
6137 DIFF=$ac_cv_path_DIFF
6138 if test -n "$DIFF"; then
6139 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6140 $as_echo "$DIFF" >&6; }
6141 else
6142 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6143 $as_echo "no" >&6; }
6144 fi
6145
6146
6147 test -n "$DIFF" && break
6148 done
6149
6150 else
6151 # If it succeeded, then it was overridden by the user. We will use it
6152 # for the tool.
6153
6154 # First remove it from the list of overridden variables, so we can test
6155 # for unknown variables in the end.
6156 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6157
6158 # Check if the provided tool contains a complete path.
6159 tool_specified="$DIFF"
6160 tool_basename="${tool_specified##*/}"
6161 if test "x$tool_basename" = "x$tool_specified"; then
6162 # A command without a complete path is provided, search $PATH.
6163 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6164 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6165 # Extract the first word of "$tool_basename", so it can be a program name with args.
6166 set dummy $tool_basename; ac_word=$2
6167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6168 $as_echo_n "checking for $ac_word... " >&6; }
6169 if ${ac_cv_path_DIFF+:} false; then :
6170 $as_echo_n "(cached) " >&6
6171 else
6172 case $DIFF in
6173 [\\/]* | ?:[\\/]*)
6174 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6175 ;;
6176 *)
6177 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6178 for as_dir in $PATH
6179 do
6180 IFS=$as_save_IFS
6181 test -z "$as_dir" && as_dir=.
6182 for ac_exec_ext in '' $ac_executable_extensions; do
6183 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6184 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6185 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6186 break 2
6187 fi
6188 done
6189 done
6190 IFS=$as_save_IFS
6191
6192 ;;
6193 esac
6194 fi
6195 DIFF=$ac_cv_path_DIFF
6196 if test -n "$DIFF"; then
6197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6198 $as_echo "$DIFF" >&6; }
6199 else
6200 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6201 $as_echo "no" >&6; }
6202 fi
6203
6204
6205 if test "x$DIFF" = x; then
6206 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6207 fi
6208 else
6209 # Otherwise we believe it is a complete path. Use it as it is.
6210 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6211 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6212 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6213 $as_echo_n "checking for DIFF... " >&6; }
6214 if test ! -x "$tool_specified"; then
6215 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6216 $as_echo "not found" >&6; }
6217 as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6218 fi
6219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6220 $as_echo "$tool_specified" >&6; }
6221 fi
6222 fi
6223 fi
6224
6225
6226
6227 if test "x$DIFF" = x; then
6228 as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6229 fi
6230
6231
6232
6233
6234
6235 # Publish this variable in the help.
6236
6237
6238 if test "x$DIRNAME" = x; then
6239 # The variable is not set by user, try to locate tool using the code snippet
6240 for ac_prog in dirname
6241 do
6242 # Extract the first word of "$ac_prog", so it can be a program name with args.
6243 set dummy $ac_prog; ac_word=$2
6244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6245 $as_echo_n "checking for $ac_word... " >&6; }
6246 if ${ac_cv_path_DIRNAME+:} false; then :
6247 $as_echo_n "(cached) " >&6
6248 else
6249 case $DIRNAME in
6250 [\\/]* | ?:[\\/]*)
6251 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6252 ;;
6253 *)
6254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6255 for as_dir in $PATH
6256 do
6257 IFS=$as_save_IFS
6258 test -z "$as_dir" && as_dir=.
6259 for ac_exec_ext in '' $ac_executable_extensions; do
6260 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6261 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6262 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6263 break 2
6264 fi
6265 done
6266 done
6267 IFS=$as_save_IFS
6268
6269 ;;
6270 esac
6271 fi
6272 DIRNAME=$ac_cv_path_DIRNAME
6273 if test -n "$DIRNAME"; then
6274 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6275 $as_echo "$DIRNAME" >&6; }
6276 else
6277 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6278 $as_echo "no" >&6; }
6279 fi
6280
6281
6282 test -n "$DIRNAME" && break
6283 done
6284
6285 else
6286 # The variable is set, but is it from the command line or the environment?
6287
6288 # Try to remove the string !DIRNAME! from our list.
6289 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6290 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6291 # If it failed, the variable was not from the command line. Ignore it,
6292 # but warn the user (except for BASH, which is always set by the calling BASH).
6293 if test "xDIRNAME" != xBASH; then
6294 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6295 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6296 fi
6297 # Try to locate tool using the code snippet
6298 for ac_prog in dirname
6299 do
6300 # Extract the first word of "$ac_prog", so it can be a program name with args.
6301 set dummy $ac_prog; ac_word=$2
6302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6303 $as_echo_n "checking for $ac_word... " >&6; }
6304 if ${ac_cv_path_DIRNAME+:} false; then :
6305 $as_echo_n "(cached) " >&6
6306 else
6307 case $DIRNAME in
6308 [\\/]* | ?:[\\/]*)
6309 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6310 ;;
6311 *)
6312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6313 for as_dir in $PATH
6314 do
6315 IFS=$as_save_IFS
6316 test -z "$as_dir" && as_dir=.
6317 for ac_exec_ext in '' $ac_executable_extensions; do
6318 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6319 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6320 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6321 break 2
6322 fi
6323 done
6324 done
6325 IFS=$as_save_IFS
6326
6327 ;;
6328 esac
6329 fi
6330 DIRNAME=$ac_cv_path_DIRNAME
6331 if test -n "$DIRNAME"; then
6332 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6333 $as_echo "$DIRNAME" >&6; }
6334 else
6335 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6336 $as_echo "no" >&6; }
6337 fi
6338
6339
6340 test -n "$DIRNAME" && break
6341 done
6342
6343 else
6344 # If it succeeded, then it was overridden by the user. We will use it
6345 # for the tool.
6346
6347 # First remove it from the list of overridden variables, so we can test
6348 # for unknown variables in the end.
6349 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6350
6351 # Check if the provided tool contains a complete path.
6352 tool_specified="$DIRNAME"
6353 tool_basename="${tool_specified##*/}"
6354 if test "x$tool_basename" = "x$tool_specified"; then
6355 # A command without a complete path is provided, search $PATH.
6356 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6357 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6358 # Extract the first word of "$tool_basename", so it can be a program name with args.
6359 set dummy $tool_basename; ac_word=$2
6360 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6361 $as_echo_n "checking for $ac_word... " >&6; }
6362 if ${ac_cv_path_DIRNAME+:} false; then :
6363 $as_echo_n "(cached) " >&6
6364 else
6365 case $DIRNAME in
6366 [\\/]* | ?:[\\/]*)
6367 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6368 ;;
6369 *)
6370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6371 for as_dir in $PATH
6372 do
6373 IFS=$as_save_IFS
6374 test -z "$as_dir" && as_dir=.
6375 for ac_exec_ext in '' $ac_executable_extensions; do
6376 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6377 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6378 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6379 break 2
6380 fi
6381 done
6382 done
6383 IFS=$as_save_IFS
6384
6385 ;;
6386 esac
6387 fi
6388 DIRNAME=$ac_cv_path_DIRNAME
6389 if test -n "$DIRNAME"; then
6390 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6391 $as_echo "$DIRNAME" >&6; }
6392 else
6393 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6394 $as_echo "no" >&6; }
6395 fi
6396
6397
6398 if test "x$DIRNAME" = x; then
6399 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6400 fi
6401 else
6402 # Otherwise we believe it is a complete path. Use it as it is.
6403 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6404 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6406 $as_echo_n "checking for DIRNAME... " >&6; }
6407 if test ! -x "$tool_specified"; then
6408 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6409 $as_echo "not found" >&6; }
6410 as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6411 fi
6412 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6413 $as_echo "$tool_specified" >&6; }
6414 fi
6415 fi
6416 fi
6417
6418
6419
6420 if test "x$DIRNAME" = x; then
6421 as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6422 fi
6423
6424
6425
6426
6427
6428 # Publish this variable in the help.
6429
6430
6431 if test "x$ECHO" = x; then
6432 # The variable is not set by user, try to locate tool using the code snippet
6433 for ac_prog in echo
6434 do
6435 # Extract the first word of "$ac_prog", so it can be a program name with args.
6436 set dummy $ac_prog; ac_word=$2
6437 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6438 $as_echo_n "checking for $ac_word... " >&6; }
6439 if ${ac_cv_path_ECHO+:} false; then :
6440 $as_echo_n "(cached) " >&6
6441 else
6442 case $ECHO in
6443 [\\/]* | ?:[\\/]*)
6444 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6445 ;;
6446 *)
6447 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6448 for as_dir in $PATH
6449 do
6450 IFS=$as_save_IFS
6451 test -z "$as_dir" && as_dir=.
6452 for ac_exec_ext in '' $ac_executable_extensions; do
6453 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6454 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6455 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6456 break 2
6457 fi
6458 done
6459 done
6460 IFS=$as_save_IFS
6461
6462 ;;
6463 esac
6464 fi
6465 ECHO=$ac_cv_path_ECHO
6466 if test -n "$ECHO"; then
6467 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6468 $as_echo "$ECHO" >&6; }
6469 else
6470 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6471 $as_echo "no" >&6; }
6472 fi
6473
6474
6475 test -n "$ECHO" && break
6476 done
6477
6478 else
6479 # The variable is set, but is it from the command line or the environment?
6480
6481 # Try to remove the string !ECHO! from our list.
6482 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6483 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6484 # If it failed, the variable was not from the command line. Ignore it,
6485 # but warn the user (except for BASH, which is always set by the calling BASH).
6486 if test "xECHO" != xBASH; then
6487 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6488 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6489 fi
6490 # Try to locate tool using the code snippet
6491 for ac_prog in echo
6492 do
6493 # Extract the first word of "$ac_prog", so it can be a program name with args.
6494 set dummy $ac_prog; ac_word=$2
6495 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6496 $as_echo_n "checking for $ac_word... " >&6; }
6497 if ${ac_cv_path_ECHO+:} false; then :
6498 $as_echo_n "(cached) " >&6
6499 else
6500 case $ECHO in
6501 [\\/]* | ?:[\\/]*)
6502 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6503 ;;
6504 *)
6505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6506 for as_dir in $PATH
6507 do
6508 IFS=$as_save_IFS
6509 test -z "$as_dir" && as_dir=.
6510 for ac_exec_ext in '' $ac_executable_extensions; do
6511 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6512 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6513 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6514 break 2
6515 fi
6516 done
6517 done
6518 IFS=$as_save_IFS
6519
6520 ;;
6521 esac
6522 fi
6523 ECHO=$ac_cv_path_ECHO
6524 if test -n "$ECHO"; then
6525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6526 $as_echo "$ECHO" >&6; }
6527 else
6528 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6529 $as_echo "no" >&6; }
6530 fi
6531
6532
6533 test -n "$ECHO" && break
6534 done
6535
6536 else
6537 # If it succeeded, then it was overridden by the user. We will use it
6538 # for the tool.
6539
6540 # First remove it from the list of overridden variables, so we can test
6541 # for unknown variables in the end.
6542 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6543
6544 # Check if the provided tool contains a complete path.
6545 tool_specified="$ECHO"
6546 tool_basename="${tool_specified##*/}"
6547 if test "x$tool_basename" = "x$tool_specified"; then
6548 # A command without a complete path is provided, search $PATH.
6549 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6550 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6551 # Extract the first word of "$tool_basename", so it can be a program name with args.
6552 set dummy $tool_basename; ac_word=$2
6553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6554 $as_echo_n "checking for $ac_word... " >&6; }
6555 if ${ac_cv_path_ECHO+:} false; then :
6556 $as_echo_n "(cached) " >&6
6557 else
6558 case $ECHO in
6559 [\\/]* | ?:[\\/]*)
6560 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6561 ;;
6562 *)
6563 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6564 for as_dir in $PATH
6565 do
6566 IFS=$as_save_IFS
6567 test -z "$as_dir" && as_dir=.
6568 for ac_exec_ext in '' $ac_executable_extensions; do
6569 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6570 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6571 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6572 break 2
6573 fi
6574 done
6575 done
6576 IFS=$as_save_IFS
6577
6578 ;;
6579 esac
6580 fi
6581 ECHO=$ac_cv_path_ECHO
6582 if test -n "$ECHO"; then
6583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6584 $as_echo "$ECHO" >&6; }
6585 else
6586 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6587 $as_echo "no" >&6; }
6588 fi
6589
6590
6591 if test "x$ECHO" = x; then
6592 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6593 fi
6594 else
6595 # Otherwise we believe it is a complete path. Use it as it is.
6596 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6597 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6598 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6599 $as_echo_n "checking for ECHO... " >&6; }
6600 if test ! -x "$tool_specified"; then
6601 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6602 $as_echo "not found" >&6; }
6603 as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6604 fi
6605 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6606 $as_echo "$tool_specified" >&6; }
6607 fi
6608 fi
6609 fi
6610
6611
6612
6613 if test "x$ECHO" = x; then
6614 as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6615 fi
6616
6617
6618
6619
6620
6621 # Publish this variable in the help.
6622
6623
6624 if test "x$EXPR" = x; then
6625 # The variable is not set by user, try to locate tool using the code snippet
6626 for ac_prog in expr
6627 do
6628 # Extract the first word of "$ac_prog", so it can be a program name with args.
6629 set dummy $ac_prog; ac_word=$2
6630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6631 $as_echo_n "checking for $ac_word... " >&6; }
6632 if ${ac_cv_path_EXPR+:} false; then :
6633 $as_echo_n "(cached) " >&6
6634 else
6635 case $EXPR in
6636 [\\/]* | ?:[\\/]*)
6637 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6638 ;;
6639 *)
6640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6641 for as_dir in $PATH
6642 do
6643 IFS=$as_save_IFS
6644 test -z "$as_dir" && as_dir=.
6645 for ac_exec_ext in '' $ac_executable_extensions; do
6646 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6647 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6648 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6649 break 2
6650 fi
6651 done
6652 done
6653 IFS=$as_save_IFS
6654
6655 ;;
6656 esac
6657 fi
6658 EXPR=$ac_cv_path_EXPR
6659 if test -n "$EXPR"; then
6660 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6661 $as_echo "$EXPR" >&6; }
6662 else
6663 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6664 $as_echo "no" >&6; }
6665 fi
6666
6667
6668 test -n "$EXPR" && break
6669 done
6670
6671 else
6672 # The variable is set, but is it from the command line or the environment?
6673
6674 # Try to remove the string !EXPR! from our list.
6675 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6676 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6677 # If it failed, the variable was not from the command line. Ignore it,
6678 # but warn the user (except for BASH, which is always set by the calling BASH).
6679 if test "xEXPR" != xBASH; then
6680 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6681 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6682 fi
6683 # Try to locate tool using the code snippet
6684 for ac_prog in expr
6685 do
6686 # Extract the first word of "$ac_prog", so it can be a program name with args.
6687 set dummy $ac_prog; ac_word=$2
6688 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6689 $as_echo_n "checking for $ac_word... " >&6; }
6690 if ${ac_cv_path_EXPR+:} false; then :
6691 $as_echo_n "(cached) " >&6
6692 else
6693 case $EXPR in
6694 [\\/]* | ?:[\\/]*)
6695 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6696 ;;
6697 *)
6698 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6699 for as_dir in $PATH
6700 do
6701 IFS=$as_save_IFS
6702 test -z "$as_dir" && as_dir=.
6703 for ac_exec_ext in '' $ac_executable_extensions; do
6704 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6705 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6706 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6707 break 2
6708 fi
6709 done
6710 done
6711 IFS=$as_save_IFS
6712
6713 ;;
6714 esac
6715 fi
6716 EXPR=$ac_cv_path_EXPR
6717 if test -n "$EXPR"; then
6718 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6719 $as_echo "$EXPR" >&6; }
6720 else
6721 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6722 $as_echo "no" >&6; }
6723 fi
6724
6725
6726 test -n "$EXPR" && break
6727 done
6728
6729 else
6730 # If it succeeded, then it was overridden by the user. We will use it
6731 # for the tool.
6732
6733 # First remove it from the list of overridden variables, so we can test
6734 # for unknown variables in the end.
6735 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6736
6737 # Check if the provided tool contains a complete path.
6738 tool_specified="$EXPR"
6739 tool_basename="${tool_specified##*/}"
6740 if test "x$tool_basename" = "x$tool_specified"; then
6741 # A command without a complete path is provided, search $PATH.
6742 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6743 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6744 # Extract the first word of "$tool_basename", so it can be a program name with args.
6745 set dummy $tool_basename; ac_word=$2
6746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6747 $as_echo_n "checking for $ac_word... " >&6; }
6748 if ${ac_cv_path_EXPR+:} false; then :
6749 $as_echo_n "(cached) " >&6
6750 else
6751 case $EXPR in
6752 [\\/]* | ?:[\\/]*)
6753 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6754 ;;
6755 *)
6756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6757 for as_dir in $PATH
6758 do
6759 IFS=$as_save_IFS
6760 test -z "$as_dir" && as_dir=.
6761 for ac_exec_ext in '' $ac_executable_extensions; do
6762 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6763 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6764 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6765 break 2
6766 fi
6767 done
6768 done
6769 IFS=$as_save_IFS
6770
6771 ;;
6772 esac
6773 fi
6774 EXPR=$ac_cv_path_EXPR
6775 if test -n "$EXPR"; then
6776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6777 $as_echo "$EXPR" >&6; }
6778 else
6779 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6780 $as_echo "no" >&6; }
6781 fi
6782
6783
6784 if test "x$EXPR" = x; then
6785 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6786 fi
6787 else
6788 # Otherwise we believe it is a complete path. Use it as it is.
6789 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6790 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6791 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6792 $as_echo_n "checking for EXPR... " >&6; }
6793 if test ! -x "$tool_specified"; then
6794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6795 $as_echo "not found" >&6; }
6796 as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6797 fi
6798 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6799 $as_echo "$tool_specified" >&6; }
6800 fi
6801 fi
6802 fi
6803
6804
6805
6806 if test "x$EXPR" = x; then
6807 as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6808 fi
6809
6810
6811
6812
6813
6814 # Publish this variable in the help.
6815
6816
6817 if test "x$FILE" = x; then
6818 # The variable is not set by user, try to locate tool using the code snippet
6819 for ac_prog in file
6820 do
6821 # Extract the first word of "$ac_prog", so it can be a program name with args.
6822 set dummy $ac_prog; ac_word=$2
6823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6824 $as_echo_n "checking for $ac_word... " >&6; }
6825 if ${ac_cv_path_FILE+:} false; then :
6826 $as_echo_n "(cached) " >&6
6827 else
6828 case $FILE in
6829 [\\/]* | ?:[\\/]*)
6830 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6831 ;;
6832 *)
6833 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6834 for as_dir in $PATH
6835 do
6836 IFS=$as_save_IFS
6837 test -z "$as_dir" && as_dir=.
6838 for ac_exec_ext in '' $ac_executable_extensions; do
6839 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6840 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6841 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6842 break 2
6843 fi
6844 done
6845 done
6846 IFS=$as_save_IFS
6847
6848 ;;
6849 esac
6850 fi
6851 FILE=$ac_cv_path_FILE
6852 if test -n "$FILE"; then
6853 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6854 $as_echo "$FILE" >&6; }
6855 else
6856 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6857 $as_echo "no" >&6; }
6858 fi
6859
6860
6861 test -n "$FILE" && break
6862 done
6863
6864 else
6865 # The variable is set, but is it from the command line or the environment?
6866
6867 # Try to remove the string !FILE! from our list.
6868 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
6869 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6870 # If it failed, the variable was not from the command line. Ignore it,
6871 # but warn the user (except for BASH, which is always set by the calling BASH).
6872 if test "xFILE" != xBASH; then
6873 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
6874 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
6875 fi
6876 # Try to locate tool using the code snippet
6877 for ac_prog in file
6878 do
6879 # Extract the first word of "$ac_prog", so it can be a program name with args.
6880 set dummy $ac_prog; ac_word=$2
6881 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6882 $as_echo_n "checking for $ac_word... " >&6; }
6883 if ${ac_cv_path_FILE+:} false; then :
6884 $as_echo_n "(cached) " >&6
6885 else
6886 case $FILE in
6887 [\\/]* | ?:[\\/]*)
6888 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6889 ;;
6890 *)
6891 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6892 for as_dir in $PATH
6893 do
6894 IFS=$as_save_IFS
6895 test -z "$as_dir" && as_dir=.
6896 for ac_exec_ext in '' $ac_executable_extensions; do
6897 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6898 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6899 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6900 break 2
6901 fi
6902 done
6903 done
6904 IFS=$as_save_IFS
6905
6906 ;;
6907 esac
6908 fi
6909 FILE=$ac_cv_path_FILE
6910 if test -n "$FILE"; then
6911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6912 $as_echo "$FILE" >&6; }
6913 else
6914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6915 $as_echo "no" >&6; }
6916 fi
6917
6918
6919 test -n "$FILE" && break
6920 done
6921
6922 else
6923 # If it succeeded, then it was overridden by the user. We will use it
6924 # for the tool.
6925
6926 # First remove it from the list of overridden variables, so we can test
6927 # for unknown variables in the end.
6928 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6929
6930 # Check if the provided tool contains a complete path.
6931 tool_specified="$FILE"
6932 tool_basename="${tool_specified##*/}"
6933 if test "x$tool_basename" = "x$tool_specified"; then
6934 # A command without a complete path is provided, search $PATH.
6935 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
6936 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
6937 # Extract the first word of "$tool_basename", so it can be a program name with args.
6938 set dummy $tool_basename; ac_word=$2
6939 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6940 $as_echo_n "checking for $ac_word... " >&6; }
6941 if ${ac_cv_path_FILE+:} false; then :
6942 $as_echo_n "(cached) " >&6
6943 else
6944 case $FILE in
6945 [\\/]* | ?:[\\/]*)
6946 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6947 ;;
6948 *)
6949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6950 for as_dir in $PATH
6951 do
6952 IFS=$as_save_IFS
6953 test -z "$as_dir" && as_dir=.
6954 for ac_exec_ext in '' $ac_executable_extensions; do
6955 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6956 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6957 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6958 break 2
6959 fi
6960 done
6961 done
6962 IFS=$as_save_IFS
6963
6964 ;;
6965 esac
6966 fi
6967 FILE=$ac_cv_path_FILE
6968 if test -n "$FILE"; then
6969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6970 $as_echo "$FILE" >&6; }
6971 else
6972 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6973 $as_echo "no" >&6; }
6974 fi
6975
6976
6977 if test "x$FILE" = x; then
6978 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6979 fi
6980 else
6981 # Otherwise we believe it is a complete path. Use it as it is.
6982 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
6983 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
6984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
6985 $as_echo_n "checking for FILE... " >&6; }
6986 if test ! -x "$tool_specified"; then
6987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6988 $as_echo "not found" >&6; }
6989 as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
6990 fi
6991 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6992 $as_echo "$tool_specified" >&6; }
6993 fi
6994 fi
6995 fi
6996
6997
6998
6999 if test "x$FILE" = x; then
7000 as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7001 fi
7002
7003
7004
7005
7006
7007 # Publish this variable in the help.
7008
7009
7010 if test "x$FIND" = x; then
7011 # The variable is not set by user, try to locate tool using the code snippet
7012 for ac_prog in find
7013 do
7014 # Extract the first word of "$ac_prog", so it can be a program name with args.
7015 set dummy $ac_prog; ac_word=$2
7016 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7017 $as_echo_n "checking for $ac_word... " >&6; }
7018 if ${ac_cv_path_FIND+:} false; then :
7019 $as_echo_n "(cached) " >&6
7020 else
7021 case $FIND in
7022 [\\/]* | ?:[\\/]*)
7023 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7024 ;;
7025 *)
7026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7027 for as_dir in $PATH
7028 do
7029 IFS=$as_save_IFS
7030 test -z "$as_dir" && as_dir=.
7031 for ac_exec_ext in '' $ac_executable_extensions; do
7032 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7033 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7034 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7035 break 2
7036 fi
7037 done
7038 done
7039 IFS=$as_save_IFS
7040
7041 ;;
7042 esac
7043 fi
7044 FIND=$ac_cv_path_FIND
7045 if test -n "$FIND"; then
7046 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7047 $as_echo "$FIND" >&6; }
7048 else
7049 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7050 $as_echo "no" >&6; }
7051 fi
7052
7053
7054 test -n "$FIND" && break
7055 done
7056
7057 else
7058 # The variable is set, but is it from the command line or the environment?
7059
7060 # Try to remove the string !FIND! from our list.
7061 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7062 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7063 # If it failed, the variable was not from the command line. Ignore it,
7064 # but warn the user (except for BASH, which is always set by the calling BASH).
7065 if test "xFIND" != xBASH; then
7066 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7067 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7068 fi
7069 # Try to locate tool using the code snippet
7070 for ac_prog in find
7071 do
7072 # Extract the first word of "$ac_prog", so it can be a program name with args.
7073 set dummy $ac_prog; ac_word=$2
7074 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7075 $as_echo_n "checking for $ac_word... " >&6; }
7076 if ${ac_cv_path_FIND+:} false; then :
7077 $as_echo_n "(cached) " >&6
7078 else
7079 case $FIND in
7080 [\\/]* | ?:[\\/]*)
7081 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7082 ;;
7083 *)
7084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7085 for as_dir in $PATH
7086 do
7087 IFS=$as_save_IFS
7088 test -z "$as_dir" && as_dir=.
7089 for ac_exec_ext in '' $ac_executable_extensions; do
7090 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7091 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7092 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7093 break 2
7094 fi
7095 done
7096 done
7097 IFS=$as_save_IFS
7098
7099 ;;
7100 esac
7101 fi
7102 FIND=$ac_cv_path_FIND
7103 if test -n "$FIND"; then
7104 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7105 $as_echo "$FIND" >&6; }
7106 else
7107 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7108 $as_echo "no" >&6; }
7109 fi
7110
7111
7112 test -n "$FIND" && break
7113 done
7114
7115 else
7116 # If it succeeded, then it was overridden by the user. We will use it
7117 # for the tool.
7118
7119 # First remove it from the list of overridden variables, so we can test
7120 # for unknown variables in the end.
7121 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7122
7123 # Check if the provided tool contains a complete path.
7124 tool_specified="$FIND"
7125 tool_basename="${tool_specified##*/}"
7126 if test "x$tool_basename" = "x$tool_specified"; then
7127 # A command without a complete path is provided, search $PATH.
7128 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7129 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7130 # Extract the first word of "$tool_basename", so it can be a program name with args.
7131 set dummy $tool_basename; ac_word=$2
7132 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7133 $as_echo_n "checking for $ac_word... " >&6; }
7134 if ${ac_cv_path_FIND+:} false; then :
7135 $as_echo_n "(cached) " >&6
7136 else
7137 case $FIND in
7138 [\\/]* | ?:[\\/]*)
7139 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7140 ;;
7141 *)
7142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7143 for as_dir in $PATH
7144 do
7145 IFS=$as_save_IFS
7146 test -z "$as_dir" && as_dir=.
7147 for ac_exec_ext in '' $ac_executable_extensions; do
7148 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7149 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7150 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7151 break 2
7152 fi
7153 done
7154 done
7155 IFS=$as_save_IFS
7156
7157 ;;
7158 esac
7159 fi
7160 FIND=$ac_cv_path_FIND
7161 if test -n "$FIND"; then
7162 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7163 $as_echo "$FIND" >&6; }
7164 else
7165 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7166 $as_echo "no" >&6; }
7167 fi
7168
7169
7170 if test "x$FIND" = x; then
7171 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7172 fi
7173 else
7174 # Otherwise we believe it is a complete path. Use it as it is.
7175 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7176 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7177 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7178 $as_echo_n "checking for FIND... " >&6; }
7179 if test ! -x "$tool_specified"; then
7180 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7181 $as_echo "not found" >&6; }
7182 as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7183 fi
7184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7185 $as_echo "$tool_specified" >&6; }
7186 fi
7187 fi
7188 fi
7189
7190
7191
7192 if test "x$FIND" = x; then
7193 as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7194 fi
7195
7196
7197
7198
7199
7200 # Publish this variable in the help.
7201
7202
7203 if test "x$HEAD" = x; then
7204 # The variable is not set by user, try to locate tool using the code snippet
7205 for ac_prog in head
7206 do
7207 # Extract the first word of "$ac_prog", so it can be a program name with args.
7208 set dummy $ac_prog; ac_word=$2
7209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7210 $as_echo_n "checking for $ac_word... " >&6; }
7211 if ${ac_cv_path_HEAD+:} false; then :
7212 $as_echo_n "(cached) " >&6
7213 else
7214 case $HEAD in
7215 [\\/]* | ?:[\\/]*)
7216 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7217 ;;
7218 *)
7219 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7220 for as_dir in $PATH
7221 do
7222 IFS=$as_save_IFS
7223 test -z "$as_dir" && as_dir=.
7224 for ac_exec_ext in '' $ac_executable_extensions; do
7225 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7226 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7227 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7228 break 2
7229 fi
7230 done
7231 done
7232 IFS=$as_save_IFS
7233
7234 ;;
7235 esac
7236 fi
7237 HEAD=$ac_cv_path_HEAD
7238 if test -n "$HEAD"; then
7239 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7240 $as_echo "$HEAD" >&6; }
7241 else
7242 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7243 $as_echo "no" >&6; }
7244 fi
7245
7246
7247 test -n "$HEAD" && break
7248 done
7249
7250 else
7251 # The variable is set, but is it from the command line or the environment?
7252
7253 # Try to remove the string !HEAD! from our list.
7254 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7255 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7256 # If it failed, the variable was not from the command line. Ignore it,
7257 # but warn the user (except for BASH, which is always set by the calling BASH).
7258 if test "xHEAD" != xBASH; then
7259 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7260 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7261 fi
7262 # Try to locate tool using the code snippet
7263 for ac_prog in head
7264 do
7265 # Extract the first word of "$ac_prog", so it can be a program name with args.
7266 set dummy $ac_prog; ac_word=$2
7267 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7268 $as_echo_n "checking for $ac_word... " >&6; }
7269 if ${ac_cv_path_HEAD+:} false; then :
7270 $as_echo_n "(cached) " >&6
7271 else
7272 case $HEAD in
7273 [\\/]* | ?:[\\/]*)
7274 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7275 ;;
7276 *)
7277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7278 for as_dir in $PATH
7279 do
7280 IFS=$as_save_IFS
7281 test -z "$as_dir" && as_dir=.
7282 for ac_exec_ext in '' $ac_executable_extensions; do
7283 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7284 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7285 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7286 break 2
7287 fi
7288 done
7289 done
7290 IFS=$as_save_IFS
7291
7292 ;;
7293 esac
7294 fi
7295 HEAD=$ac_cv_path_HEAD
7296 if test -n "$HEAD"; then
7297 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7298 $as_echo "$HEAD" >&6; }
7299 else
7300 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7301 $as_echo "no" >&6; }
7302 fi
7303
7304
7305 test -n "$HEAD" && break
7306 done
7307
7308 else
7309 # If it succeeded, then it was overridden by the user. We will use it
7310 # for the tool.
7311
7312 # First remove it from the list of overridden variables, so we can test
7313 # for unknown variables in the end.
7314 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7315
7316 # Check if the provided tool contains a complete path.
7317 tool_specified="$HEAD"
7318 tool_basename="${tool_specified##*/}"
7319 if test "x$tool_basename" = "x$tool_specified"; then
7320 # A command without a complete path is provided, search $PATH.
7321 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7322 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7323 # Extract the first word of "$tool_basename", so it can be a program name with args.
7324 set dummy $tool_basename; ac_word=$2
7325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7326 $as_echo_n "checking for $ac_word... " >&6; }
7327 if ${ac_cv_path_HEAD+:} false; then :
7328 $as_echo_n "(cached) " >&6
7329 else
7330 case $HEAD in
7331 [\\/]* | ?:[\\/]*)
7332 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7333 ;;
7334 *)
7335 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7336 for as_dir in $PATH
7337 do
7338 IFS=$as_save_IFS
7339 test -z "$as_dir" && as_dir=.
7340 for ac_exec_ext in '' $ac_executable_extensions; do
7341 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7342 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7343 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7344 break 2
7345 fi
7346 done
7347 done
7348 IFS=$as_save_IFS
7349
7350 ;;
7351 esac
7352 fi
7353 HEAD=$ac_cv_path_HEAD
7354 if test -n "$HEAD"; then
7355 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7356 $as_echo "$HEAD" >&6; }
7357 else
7358 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7359 $as_echo "no" >&6; }
7360 fi
7361
7362
7363 if test "x$HEAD" = x; then
7364 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7365 fi
7366 else
7367 # Otherwise we believe it is a complete path. Use it as it is.
7368 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7369 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7370 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7371 $as_echo_n "checking for HEAD... " >&6; }
7372 if test ! -x "$tool_specified"; then
7373 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7374 $as_echo "not found" >&6; }
7375 as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7376 fi
7377 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7378 $as_echo "$tool_specified" >&6; }
7379 fi
7380 fi
7381 fi
7382
7383
7384
7385 if test "x$HEAD" = x; then
7386 as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7387 fi
7388
7389
7390
7391
7392
7393 # Publish this variable in the help.
7394
7395
7396 if test "x$LN" = x; then
7397 # The variable is not set by user, try to locate tool using the code snippet
7398 for ac_prog in ln
7399 do
7400 # Extract the first word of "$ac_prog", so it can be a program name with args.
7401 set dummy $ac_prog; ac_word=$2
7402 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7403 $as_echo_n "checking for $ac_word... " >&6; }
7404 if ${ac_cv_path_LN+:} false; then :
7405 $as_echo_n "(cached) " >&6
7406 else
7407 case $LN in
7408 [\\/]* | ?:[\\/]*)
7409 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7410 ;;
7411 *)
7412 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7413 for as_dir in $PATH
7414 do
7415 IFS=$as_save_IFS
7416 test -z "$as_dir" && as_dir=.
7417 for ac_exec_ext in '' $ac_executable_extensions; do
7418 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7419 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7420 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7421 break 2
7422 fi
7423 done
7424 done
7425 IFS=$as_save_IFS
7426
7427 ;;
7428 esac
7429 fi
7430 LN=$ac_cv_path_LN
7431 if test -n "$LN"; then
7432 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7433 $as_echo "$LN" >&6; }
7434 else
7435 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7436 $as_echo "no" >&6; }
7437 fi
7438
7439
7440 test -n "$LN" && break
7441 done
7442
7443 else
7444 # The variable is set, but is it from the command line or the environment?
7445
7446 # Try to remove the string !LN! from our list.
7447 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7448 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7449 # If it failed, the variable was not from the command line. Ignore it,
7450 # but warn the user (except for BASH, which is always set by the calling BASH).
7451 if test "xLN" != xBASH; then
7452 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7453 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7454 fi
7455 # Try to locate tool using the code snippet
7456 for ac_prog in ln
7457 do
7458 # Extract the first word of "$ac_prog", so it can be a program name with args.
7459 set dummy $ac_prog; ac_word=$2
7460 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7461 $as_echo_n "checking for $ac_word... " >&6; }
7462 if ${ac_cv_path_LN+:} false; then :
7463 $as_echo_n "(cached) " >&6
7464 else
7465 case $LN in
7466 [\\/]* | ?:[\\/]*)
7467 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7468 ;;
7469 *)
7470 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7471 for as_dir in $PATH
7472 do
7473 IFS=$as_save_IFS
7474 test -z "$as_dir" && as_dir=.
7475 for ac_exec_ext in '' $ac_executable_extensions; do
7476 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7477 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7478 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7479 break 2
7480 fi
7481 done
7482 done
7483 IFS=$as_save_IFS
7484
7485 ;;
7486 esac
7487 fi
7488 LN=$ac_cv_path_LN
7489 if test -n "$LN"; then
7490 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7491 $as_echo "$LN" >&6; }
7492 else
7493 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7494 $as_echo "no" >&6; }
7495 fi
7496
7497
7498 test -n "$LN" && break
7499 done
7500
7501 else
7502 # If it succeeded, then it was overridden by the user. We will use it
7503 # for the tool.
7504
7505 # First remove it from the list of overridden variables, so we can test
7506 # for unknown variables in the end.
7507 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7508
7509 # Check if the provided tool contains a complete path.
7510 tool_specified="$LN"
7511 tool_basename="${tool_specified##*/}"
7512 if test "x$tool_basename" = "x$tool_specified"; then
7513 # A command without a complete path is provided, search $PATH.
7514 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7515 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7516 # Extract the first word of "$tool_basename", so it can be a program name with args.
7517 set dummy $tool_basename; ac_word=$2
7518 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7519 $as_echo_n "checking for $ac_word... " >&6; }
7520 if ${ac_cv_path_LN+:} false; then :
7521 $as_echo_n "(cached) " >&6
7522 else
7523 case $LN in
7524 [\\/]* | ?:[\\/]*)
7525 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7526 ;;
7527 *)
7528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7529 for as_dir in $PATH
7530 do
7531 IFS=$as_save_IFS
7532 test -z "$as_dir" && as_dir=.
7533 for ac_exec_ext in '' $ac_executable_extensions; do
7534 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7535 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7536 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7537 break 2
7538 fi
7539 done
7540 done
7541 IFS=$as_save_IFS
7542
7543 ;;
7544 esac
7545 fi
7546 LN=$ac_cv_path_LN
7547 if test -n "$LN"; then
7548 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7549 $as_echo "$LN" >&6; }
7550 else
7551 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7552 $as_echo "no" >&6; }
7553 fi
7554
7555
7556 if test "x$LN" = x; then
7557 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7558 fi
7559 else
7560 # Otherwise we believe it is a complete path. Use it as it is.
7561 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7562 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7563 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7564 $as_echo_n "checking for LN... " >&6; }
7565 if test ! -x "$tool_specified"; then
7566 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7567 $as_echo "not found" >&6; }
7568 as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7569 fi
7570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7571 $as_echo "$tool_specified" >&6; }
7572 fi
7573 fi
7574 fi
7575
7576
7577
7578 if test "x$LN" = x; then
7579 as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7580 fi
7581
7582
7583
7584
7585
7586 # Publish this variable in the help.
7587
7588
7589 if test "x$LS" = x; then
7590 # The variable is not set by user, try to locate tool using the code snippet
7591 for ac_prog in ls
7592 do
7593 # Extract the first word of "$ac_prog", so it can be a program name with args.
7594 set dummy $ac_prog; ac_word=$2
7595 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7596 $as_echo_n "checking for $ac_word... " >&6; }
7597 if ${ac_cv_path_LS+:} false; then :
7598 $as_echo_n "(cached) " >&6
7599 else
7600 case $LS in
7601 [\\/]* | ?:[\\/]*)
7602 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7603 ;;
7604 *)
7605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7606 for as_dir in $PATH
7607 do
7608 IFS=$as_save_IFS
7609 test -z "$as_dir" && as_dir=.
7610 for ac_exec_ext in '' $ac_executable_extensions; do
7611 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7612 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7613 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7614 break 2
7615 fi
7616 done
7617 done
7618 IFS=$as_save_IFS
7619
7620 ;;
7621 esac
7622 fi
7623 LS=$ac_cv_path_LS
7624 if test -n "$LS"; then
7625 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7626 $as_echo "$LS" >&6; }
7627 else
7628 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7629 $as_echo "no" >&6; }
7630 fi
7631
7632
7633 test -n "$LS" && break
7634 done
7635
7636 else
7637 # The variable is set, but is it from the command line or the environment?
7638
7639 # Try to remove the string !LS! from our list.
7640 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7641 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7642 # If it failed, the variable was not from the command line. Ignore it,
7643 # but warn the user (except for BASH, which is always set by the calling BASH).
7644 if test "xLS" != xBASH; then
7645 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7646 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7647 fi
7648 # Try to locate tool using the code snippet
7649 for ac_prog in ls
7650 do
7651 # Extract the first word of "$ac_prog", so it can be a program name with args.
7652 set dummy $ac_prog; ac_word=$2
7653 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7654 $as_echo_n "checking for $ac_word... " >&6; }
7655 if ${ac_cv_path_LS+:} false; then :
7656 $as_echo_n "(cached) " >&6
7657 else
7658 case $LS in
7659 [\\/]* | ?:[\\/]*)
7660 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7661 ;;
7662 *)
7663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7664 for as_dir in $PATH
7665 do
7666 IFS=$as_save_IFS
7667 test -z "$as_dir" && as_dir=.
7668 for ac_exec_ext in '' $ac_executable_extensions; do
7669 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7670 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7671 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7672 break 2
7673 fi
7674 done
7675 done
7676 IFS=$as_save_IFS
7677
7678 ;;
7679 esac
7680 fi
7681 LS=$ac_cv_path_LS
7682 if test -n "$LS"; then
7683 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7684 $as_echo "$LS" >&6; }
7685 else
7686 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7687 $as_echo "no" >&6; }
7688 fi
7689
7690
7691 test -n "$LS" && break
7692 done
7693
7694 else
7695 # If it succeeded, then it was overridden by the user. We will use it
7696 # for the tool.
7697
7698 # First remove it from the list of overridden variables, so we can test
7699 # for unknown variables in the end.
7700 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7701
7702 # Check if the provided tool contains a complete path.
7703 tool_specified="$LS"
7704 tool_basename="${tool_specified##*/}"
7705 if test "x$tool_basename" = "x$tool_specified"; then
7706 # A command without a complete path is provided, search $PATH.
7707 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7708 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7709 # Extract the first word of "$tool_basename", so it can be a program name with args.
7710 set dummy $tool_basename; ac_word=$2
7711 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7712 $as_echo_n "checking for $ac_word... " >&6; }
7713 if ${ac_cv_path_LS+:} false; then :
7714 $as_echo_n "(cached) " >&6
7715 else
7716 case $LS in
7717 [\\/]* | ?:[\\/]*)
7718 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7719 ;;
7720 *)
7721 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7722 for as_dir in $PATH
7723 do
7724 IFS=$as_save_IFS
7725 test -z "$as_dir" && as_dir=.
7726 for ac_exec_ext in '' $ac_executable_extensions; do
7727 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7728 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7729 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7730 break 2
7731 fi
7732 done
7733 done
7734 IFS=$as_save_IFS
7735
7736 ;;
7737 esac
7738 fi
7739 LS=$ac_cv_path_LS
7740 if test -n "$LS"; then
7741 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7742 $as_echo "$LS" >&6; }
7743 else
7744 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7745 $as_echo "no" >&6; }
7746 fi
7747
7748
7749 if test "x$LS" = x; then
7750 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7751 fi
7752 else
7753 # Otherwise we believe it is a complete path. Use it as it is.
7754 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7755 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7756 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7757 $as_echo_n "checking for LS... " >&6; }
7758 if test ! -x "$tool_specified"; then
7759 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7760 $as_echo "not found" >&6; }
7761 as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7762 fi
7763 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7764 $as_echo "$tool_specified" >&6; }
7765 fi
7766 fi
7767 fi
7768
7769
7770
7771 if test "x$LS" = x; then
7772 as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7773 fi
7774
7775
7776
7777
7778
7779 # Publish this variable in the help.
7780
7781
7782 if test "x$MKDIR" = x; then
7783 # The variable is not set by user, try to locate tool using the code snippet
7784 for ac_prog in mkdir
7785 do
7786 # Extract the first word of "$ac_prog", so it can be a program name with args.
7787 set dummy $ac_prog; ac_word=$2
7788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7789 $as_echo_n "checking for $ac_word... " >&6; }
7790 if ${ac_cv_path_MKDIR+:} false; then :
7791 $as_echo_n "(cached) " >&6
7792 else
7793 case $MKDIR in
7794 [\\/]* | ?:[\\/]*)
7795 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7796 ;;
7797 *)
7798 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7799 for as_dir in $PATH
7800 do
7801 IFS=$as_save_IFS
7802 test -z "$as_dir" && as_dir=.
7803 for ac_exec_ext in '' $ac_executable_extensions; do
7804 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7805 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7806 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7807 break 2
7808 fi
7809 done
7810 done
7811 IFS=$as_save_IFS
7812
7813 ;;
7814 esac
7815 fi
7816 MKDIR=$ac_cv_path_MKDIR
7817 if test -n "$MKDIR"; then
7818 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7819 $as_echo "$MKDIR" >&6; }
7820 else
7821 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7822 $as_echo "no" >&6; }
7823 fi
7824
7825
7826 test -n "$MKDIR" && break
7827 done
7828
7829 else
7830 # The variable is set, but is it from the command line or the environment?
7831
7832 # Try to remove the string !MKDIR! from our list.
7833 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7834 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7835 # If it failed, the variable was not from the command line. Ignore it,
7836 # but warn the user (except for BASH, which is always set by the calling BASH).
7837 if test "xMKDIR" != xBASH; then
7838 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7839 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7840 fi
7841 # Try to locate tool using the code snippet
7842 for ac_prog in mkdir
7843 do
7844 # Extract the first word of "$ac_prog", so it can be a program name with args.
7845 set dummy $ac_prog; ac_word=$2
7846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7847 $as_echo_n "checking for $ac_word... " >&6; }
7848 if ${ac_cv_path_MKDIR+:} false; then :
7849 $as_echo_n "(cached) " >&6
7850 else
7851 case $MKDIR in
7852 [\\/]* | ?:[\\/]*)
7853 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7854 ;;
7855 *)
7856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7857 for as_dir in $PATH
7858 do
7859 IFS=$as_save_IFS
7860 test -z "$as_dir" && as_dir=.
7861 for ac_exec_ext in '' $ac_executable_extensions; do
7862 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7863 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7864 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7865 break 2
7866 fi
7867 done
7868 done
7869 IFS=$as_save_IFS
7870
7871 ;;
7872 esac
7873 fi
7874 MKDIR=$ac_cv_path_MKDIR
7875 if test -n "$MKDIR"; then
7876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7877 $as_echo "$MKDIR" >&6; }
7878 else
7879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7880 $as_echo "no" >&6; }
7881 fi
7882
7883
7884 test -n "$MKDIR" && break
7885 done
7886
7887 else
7888 # If it succeeded, then it was overridden by the user. We will use it
7889 # for the tool.
7890
7891 # First remove it from the list of overridden variables, so we can test
7892 # for unknown variables in the end.
7893 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7894
7895 # Check if the provided tool contains a complete path.
7896 tool_specified="$MKDIR"
7897 tool_basename="${tool_specified##*/}"
7898 if test "x$tool_basename" = "x$tool_specified"; then
7899 # A command without a complete path is provided, search $PATH.
7900 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
7901 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
7902 # Extract the first word of "$tool_basename", so it can be a program name with args.
7903 set dummy $tool_basename; ac_word=$2
7904 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7905 $as_echo_n "checking for $ac_word... " >&6; }
7906 if ${ac_cv_path_MKDIR+:} false; then :
7907 $as_echo_n "(cached) " >&6
7908 else
7909 case $MKDIR in
7910 [\\/]* | ?:[\\/]*)
7911 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7912 ;;
7913 *)
7914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7915 for as_dir in $PATH
7916 do
7917 IFS=$as_save_IFS
7918 test -z "$as_dir" && as_dir=.
7919 for ac_exec_ext in '' $ac_executable_extensions; do
7920 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7921 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7922 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7923 break 2
7924 fi
7925 done
7926 done
7927 IFS=$as_save_IFS
7928
7929 ;;
7930 esac
7931 fi
7932 MKDIR=$ac_cv_path_MKDIR
7933 if test -n "$MKDIR"; then
7934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7935 $as_echo "$MKDIR" >&6; }
7936 else
7937 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7938 $as_echo "no" >&6; }
7939 fi
7940
7941
7942 if test "x$MKDIR" = x; then
7943 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7944 fi
7945 else
7946 # Otherwise we believe it is a complete path. Use it as it is.
7947 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
7948 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
7949 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
7950 $as_echo_n "checking for MKDIR... " >&6; }
7951 if test ! -x "$tool_specified"; then
7952 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7953 $as_echo "not found" >&6; }
7954 as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
7955 fi
7956 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7957 $as_echo "$tool_specified" >&6; }
7958 fi
7959 fi
7960 fi
7961
7962
7963
7964 if test "x$MKDIR" = x; then
7965 as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
7966 fi
7967
7968
7969
7970
7971
7972 # Publish this variable in the help.
7973
7974
7975 if test "x$MKTEMP" = x; then
7976 # The variable is not set by user, try to locate tool using the code snippet
7977 for ac_prog in mktemp
7978 do
7979 # Extract the first word of "$ac_prog", so it can be a program name with args.
7980 set dummy $ac_prog; ac_word=$2
7981 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7982 $as_echo_n "checking for $ac_word... " >&6; }
7983 if ${ac_cv_path_MKTEMP+:} false; then :
7984 $as_echo_n "(cached) " >&6
7985 else
7986 case $MKTEMP in
7987 [\\/]* | ?:[\\/]*)
7988 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
7989 ;;
7990 *)
7991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7992 for as_dir in $PATH
7993 do
7994 IFS=$as_save_IFS
7995 test -z "$as_dir" && as_dir=.
7996 for ac_exec_ext in '' $ac_executable_extensions; do
7997 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7998 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
7999 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8000 break 2
8001 fi
8002 done
8003 done
8004 IFS=$as_save_IFS
8005
8006 ;;
8007 esac
8008 fi
8009 MKTEMP=$ac_cv_path_MKTEMP
8010 if test -n "$MKTEMP"; then
8011 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8012 $as_echo "$MKTEMP" >&6; }
8013 else
8014 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8015 $as_echo "no" >&6; }
8016 fi
8017
8018
8019 test -n "$MKTEMP" && break
8020 done
8021
8022 else
8023 # The variable is set, but is it from the command line or the environment?
8024
8025 # Try to remove the string !MKTEMP! from our list.
8026 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8027 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8028 # If it failed, the variable was not from the command line. Ignore it,
8029 # but warn the user (except for BASH, which is always set by the calling BASH).
8030 if test "xMKTEMP" != xBASH; then
8031 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8032 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8033 fi
8034 # Try to locate tool using the code snippet
8035 for ac_prog in mktemp
8036 do
8037 # Extract the first word of "$ac_prog", so it can be a program name with args.
8038 set dummy $ac_prog; ac_word=$2
8039 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8040 $as_echo_n "checking for $ac_word... " >&6; }
8041 if ${ac_cv_path_MKTEMP+:} false; then :
8042 $as_echo_n "(cached) " >&6
8043 else
8044 case $MKTEMP in
8045 [\\/]* | ?:[\\/]*)
8046 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8047 ;;
8048 *)
8049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8050 for as_dir in $PATH
8051 do
8052 IFS=$as_save_IFS
8053 test -z "$as_dir" && as_dir=.
8054 for ac_exec_ext in '' $ac_executable_extensions; do
8055 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8056 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8057 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8058 break 2
8059 fi
8060 done
8061 done
8062 IFS=$as_save_IFS
8063
8064 ;;
8065 esac
8066 fi
8067 MKTEMP=$ac_cv_path_MKTEMP
8068 if test -n "$MKTEMP"; then
8069 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8070 $as_echo "$MKTEMP" >&6; }
8071 else
8072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8073 $as_echo "no" >&6; }
8074 fi
8075
8076
8077 test -n "$MKTEMP" && break
8078 done
8079
8080 else
8081 # If it succeeded, then it was overridden by the user. We will use it
8082 # for the tool.
8083
8084 # First remove it from the list of overridden variables, so we can test
8085 # for unknown variables in the end.
8086 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8087
8088 # Check if the provided tool contains a complete path.
8089 tool_specified="$MKTEMP"
8090 tool_basename="${tool_specified##*/}"
8091 if test "x$tool_basename" = "x$tool_specified"; then
8092 # A command without a complete path is provided, search $PATH.
8093 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8094 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8095 # Extract the first word of "$tool_basename", so it can be a program name with args.
8096 set dummy $tool_basename; ac_word=$2
8097 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8098 $as_echo_n "checking for $ac_word... " >&6; }
8099 if ${ac_cv_path_MKTEMP+:} false; then :
8100 $as_echo_n "(cached) " >&6
8101 else
8102 case $MKTEMP in
8103 [\\/]* | ?:[\\/]*)
8104 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8105 ;;
8106 *)
8107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8108 for as_dir in $PATH
8109 do
8110 IFS=$as_save_IFS
8111 test -z "$as_dir" && as_dir=.
8112 for ac_exec_ext in '' $ac_executable_extensions; do
8113 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8114 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8115 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8116 break 2
8117 fi
8118 done
8119 done
8120 IFS=$as_save_IFS
8121
8122 ;;
8123 esac
8124 fi
8125 MKTEMP=$ac_cv_path_MKTEMP
8126 if test -n "$MKTEMP"; then
8127 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8128 $as_echo "$MKTEMP" >&6; }
8129 else
8130 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8131 $as_echo "no" >&6; }
8132 fi
8133
8134
8135 if test "x$MKTEMP" = x; then
8136 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8137 fi
8138 else
8139 # Otherwise we believe it is a complete path. Use it as it is.
8140 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8141 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8142 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8143 $as_echo_n "checking for MKTEMP... " >&6; }
8144 if test ! -x "$tool_specified"; then
8145 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8146 $as_echo "not found" >&6; }
8147 as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8148 fi
8149 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8150 $as_echo "$tool_specified" >&6; }
8151 fi
8152 fi
8153 fi
8154
8155
8156
8157 if test "x$MKTEMP" = x; then
8158 as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8159 fi
8160
8161
8162
8163
8164
8165 # Publish this variable in the help.
8166
8167
8168 if test "x$MV" = x; then
8169 # The variable is not set by user, try to locate tool using the code snippet
8170 for ac_prog in mv
8171 do
8172 # Extract the first word of "$ac_prog", so it can be a program name with args.
8173 set dummy $ac_prog; ac_word=$2
8174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8175 $as_echo_n "checking for $ac_word... " >&6; }
8176 if ${ac_cv_path_MV+:} false; then :
8177 $as_echo_n "(cached) " >&6
8178 else
8179 case $MV in
8180 [\\/]* | ?:[\\/]*)
8181 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8182 ;;
8183 *)
8184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8185 for as_dir in $PATH
8186 do
8187 IFS=$as_save_IFS
8188 test -z "$as_dir" && as_dir=.
8189 for ac_exec_ext in '' $ac_executable_extensions; do
8190 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8191 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8192 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8193 break 2
8194 fi
8195 done
8196 done
8197 IFS=$as_save_IFS
8198
8199 ;;
8200 esac
8201 fi
8202 MV=$ac_cv_path_MV
8203 if test -n "$MV"; then
8204 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8205 $as_echo "$MV" >&6; }
8206 else
8207 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8208 $as_echo "no" >&6; }
8209 fi
8210
8211
8212 test -n "$MV" && break
8213 done
8214
8215 else
8216 # The variable is set, but is it from the command line or the environment?
8217
8218 # Try to remove the string !MV! from our list.
8219 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8220 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8221 # If it failed, the variable was not from the command line. Ignore it,
8222 # but warn the user (except for BASH, which is always set by the calling BASH).
8223 if test "xMV" != xBASH; then
8224 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8225 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8226 fi
8227 # Try to locate tool using the code snippet
8228 for ac_prog in mv
8229 do
8230 # Extract the first word of "$ac_prog", so it can be a program name with args.
8231 set dummy $ac_prog; ac_word=$2
8232 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8233 $as_echo_n "checking for $ac_word... " >&6; }
8234 if ${ac_cv_path_MV+:} false; then :
8235 $as_echo_n "(cached) " >&6
8236 else
8237 case $MV in
8238 [\\/]* | ?:[\\/]*)
8239 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8240 ;;
8241 *)
8242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8243 for as_dir in $PATH
8244 do
8245 IFS=$as_save_IFS
8246 test -z "$as_dir" && as_dir=.
8247 for ac_exec_ext in '' $ac_executable_extensions; do
8248 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8249 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8250 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8251 break 2
8252 fi
8253 done
8254 done
8255 IFS=$as_save_IFS
8256
8257 ;;
8258 esac
8259 fi
8260 MV=$ac_cv_path_MV
8261 if test -n "$MV"; then
8262 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8263 $as_echo "$MV" >&6; }
8264 else
8265 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8266 $as_echo "no" >&6; }
8267 fi
8268
8269
8270 test -n "$MV" && break
8271 done
8272
8273 else
8274 # If it succeeded, then it was overridden by the user. We will use it
8275 # for the tool.
8276
8277 # First remove it from the list of overridden variables, so we can test
8278 # for unknown variables in the end.
8279 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8280
8281 # Check if the provided tool contains a complete path.
8282 tool_specified="$MV"
8283 tool_basename="${tool_specified##*/}"
8284 if test "x$tool_basename" = "x$tool_specified"; then
8285 # A command without a complete path is provided, search $PATH.
8286 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8287 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8288 # Extract the first word of "$tool_basename", so it can be a program name with args.
8289 set dummy $tool_basename; ac_word=$2
8290 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8291 $as_echo_n "checking for $ac_word... " >&6; }
8292 if ${ac_cv_path_MV+:} false; then :
8293 $as_echo_n "(cached) " >&6
8294 else
8295 case $MV in
8296 [\\/]* | ?:[\\/]*)
8297 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8298 ;;
8299 *)
8300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8301 for as_dir in $PATH
8302 do
8303 IFS=$as_save_IFS
8304 test -z "$as_dir" && as_dir=.
8305 for ac_exec_ext in '' $ac_executable_extensions; do
8306 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8307 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8308 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8309 break 2
8310 fi
8311 done
8312 done
8313 IFS=$as_save_IFS
8314
8315 ;;
8316 esac
8317 fi
8318 MV=$ac_cv_path_MV
8319 if test -n "$MV"; then
8320 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8321 $as_echo "$MV" >&6; }
8322 else
8323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8324 $as_echo "no" >&6; }
8325 fi
8326
8327
8328 if test "x$MV" = x; then
8329 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8330 fi
8331 else
8332 # Otherwise we believe it is a complete path. Use it as it is.
8333 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8334 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8335 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8336 $as_echo_n "checking for MV... " >&6; }
8337 if test ! -x "$tool_specified"; then
8338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8339 $as_echo "not found" >&6; }
8340 as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8341 fi
8342 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8343 $as_echo "$tool_specified" >&6; }
8344 fi
8345 fi
8346 fi
8347
8348
8349
8350 if test "x$MV" = x; then
8351 as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8352 fi
8353
8354
8355
8356
8357
8358 # Publish this variable in the help.
8359
8360
8361 if test "x$NAWK" = x; then
8362 # The variable is not set by user, try to locate tool using the code snippet
8363 for ac_prog in nawk gawk awk
8364 do
8365 # Extract the first word of "$ac_prog", so it can be a program name with args.
8366 set dummy $ac_prog; ac_word=$2
8367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8368 $as_echo_n "checking for $ac_word... " >&6; }
8369 if ${ac_cv_path_NAWK+:} false; then :
8370 $as_echo_n "(cached) " >&6
8371 else
8372 case $NAWK in
8373 [\\/]* | ?:[\\/]*)
8374 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8375 ;;
8376 *)
8377 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8378 for as_dir in $PATH
8379 do
8380 IFS=$as_save_IFS
8381 test -z "$as_dir" && as_dir=.
8382 for ac_exec_ext in '' $ac_executable_extensions; do
8383 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8384 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8385 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8386 break 2
8387 fi
8388 done
8389 done
8390 IFS=$as_save_IFS
8391
8392 ;;
8393 esac
8394 fi
8395 NAWK=$ac_cv_path_NAWK
8396 if test -n "$NAWK"; then
8397 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8398 $as_echo "$NAWK" >&6; }
8399 else
8400 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8401 $as_echo "no" >&6; }
8402 fi
8403
8404
8405 test -n "$NAWK" && break
8406 done
8407
8408 else
8409 # The variable is set, but is it from the command line or the environment?
8410
8411 # Try to remove the string !NAWK! from our list.
8412 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8413 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8414 # If it failed, the variable was not from the command line. Ignore it,
8415 # but warn the user (except for BASH, which is always set by the calling BASH).
8416 if test "xNAWK" != xBASH; then
8417 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8418 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8419 fi
8420 # Try to locate tool using the code snippet
8421 for ac_prog in nawk gawk awk
8422 do
8423 # Extract the first word of "$ac_prog", so it can be a program name with args.
8424 set dummy $ac_prog; ac_word=$2
8425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8426 $as_echo_n "checking for $ac_word... " >&6; }
8427 if ${ac_cv_path_NAWK+:} false; then :
8428 $as_echo_n "(cached) " >&6
8429 else
8430 case $NAWK in
8431 [\\/]* | ?:[\\/]*)
8432 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8433 ;;
8434 *)
8435 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8436 for as_dir in $PATH
8437 do
8438 IFS=$as_save_IFS
8439 test -z "$as_dir" && as_dir=.
8440 for ac_exec_ext in '' $ac_executable_extensions; do
8441 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8442 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8443 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8444 break 2
8445 fi
8446 done
8447 done
8448 IFS=$as_save_IFS
8449
8450 ;;
8451 esac
8452 fi
8453 NAWK=$ac_cv_path_NAWK
8454 if test -n "$NAWK"; then
8455 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8456 $as_echo "$NAWK" >&6; }
8457 else
8458 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8459 $as_echo "no" >&6; }
8460 fi
8461
8462
8463 test -n "$NAWK" && break
8464 done
8465
8466 else
8467 # If it succeeded, then it was overridden by the user. We will use it
8468 # for the tool.
8469
8470 # First remove it from the list of overridden variables, so we can test
8471 # for unknown variables in the end.
8472 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8473
8474 # Check if the provided tool contains a complete path.
8475 tool_specified="$NAWK"
8476 tool_basename="${tool_specified##*/}"
8477 if test "x$tool_basename" = "x$tool_specified"; then
8478 # A command without a complete path is provided, search $PATH.
8479 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8480 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8481 # Extract the first word of "$tool_basename", so it can be a program name with args.
8482 set dummy $tool_basename; ac_word=$2
8483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8484 $as_echo_n "checking for $ac_word... " >&6; }
8485 if ${ac_cv_path_NAWK+:} false; then :
8486 $as_echo_n "(cached) " >&6
8487 else
8488 case $NAWK in
8489 [\\/]* | ?:[\\/]*)
8490 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8491 ;;
8492 *)
8493 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8494 for as_dir in $PATH
8495 do
8496 IFS=$as_save_IFS
8497 test -z "$as_dir" && as_dir=.
8498 for ac_exec_ext in '' $ac_executable_extensions; do
8499 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8500 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8501 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8502 break 2
8503 fi
8504 done
8505 done
8506 IFS=$as_save_IFS
8507
8508 ;;
8509 esac
8510 fi
8511 NAWK=$ac_cv_path_NAWK
8512 if test -n "$NAWK"; then
8513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8514 $as_echo "$NAWK" >&6; }
8515 else
8516 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8517 $as_echo "no" >&6; }
8518 fi
8519
8520
8521 if test "x$NAWK" = x; then
8522 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8523 fi
8524 else
8525 # Otherwise we believe it is a complete path. Use it as it is.
8526 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8527 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8528 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8529 $as_echo_n "checking for NAWK... " >&6; }
8530 if test ! -x "$tool_specified"; then
8531 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8532 $as_echo "not found" >&6; }
8533 as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8534 fi
8535 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8536 $as_echo "$tool_specified" >&6; }
8537 fi
8538 fi
8539 fi
8540
8541
8542
8543 if test "x$NAWK" = x; then
8544 as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8545 fi
8546
8547
8548
8549
8550
8551 # Publish this variable in the help.
8552
8553
8554 if test "x$PRINTF" = x; then
8555 # The variable is not set by user, try to locate tool using the code snippet
8556 for ac_prog in printf
8557 do
8558 # Extract the first word of "$ac_prog", so it can be a program name with args.
8559 set dummy $ac_prog; ac_word=$2
8560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8561 $as_echo_n "checking for $ac_word... " >&6; }
8562 if ${ac_cv_path_PRINTF+:} false; then :
8563 $as_echo_n "(cached) " >&6
8564 else
8565 case $PRINTF in
8566 [\\/]* | ?:[\\/]*)
8567 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8568 ;;
8569 *)
8570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8571 for as_dir in $PATH
8572 do
8573 IFS=$as_save_IFS
8574 test -z "$as_dir" && as_dir=.
8575 for ac_exec_ext in '' $ac_executable_extensions; do
8576 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8577 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8578 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8579 break 2
8580 fi
8581 done
8582 done
8583 IFS=$as_save_IFS
8584
8585 ;;
8586 esac
8587 fi
8588 PRINTF=$ac_cv_path_PRINTF
8589 if test -n "$PRINTF"; then
8590 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8591 $as_echo "$PRINTF" >&6; }
8592 else
8593 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8594 $as_echo "no" >&6; }
8595 fi
8596
8597
8598 test -n "$PRINTF" && break
8599 done
8600
8601 else
8602 # The variable is set, but is it from the command line or the environment?
8603
8604 # Try to remove the string !PRINTF! from our list.
8605 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8606 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8607 # If it failed, the variable was not from the command line. Ignore it,
8608 # but warn the user (except for BASH, which is always set by the calling BASH).
8609 if test "xPRINTF" != xBASH; then
8610 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8611 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8612 fi
8613 # Try to locate tool using the code snippet
8614 for ac_prog in printf
8615 do
8616 # Extract the first word of "$ac_prog", so it can be a program name with args.
8617 set dummy $ac_prog; ac_word=$2
8618 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8619 $as_echo_n "checking for $ac_word... " >&6; }
8620 if ${ac_cv_path_PRINTF+:} false; then :
8621 $as_echo_n "(cached) " >&6
8622 else
8623 case $PRINTF in
8624 [\\/]* | ?:[\\/]*)
8625 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8626 ;;
8627 *)
8628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8629 for as_dir in $PATH
8630 do
8631 IFS=$as_save_IFS
8632 test -z "$as_dir" && as_dir=.
8633 for ac_exec_ext in '' $ac_executable_extensions; do
8634 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8635 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8636 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8637 break 2
8638 fi
8639 done
8640 done
8641 IFS=$as_save_IFS
8642
8643 ;;
8644 esac
8645 fi
8646 PRINTF=$ac_cv_path_PRINTF
8647 if test -n "$PRINTF"; then
8648 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8649 $as_echo "$PRINTF" >&6; }
8650 else
8651 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8652 $as_echo "no" >&6; }
8653 fi
8654
8655
8656 test -n "$PRINTF" && break
8657 done
8658
8659 else
8660 # If it succeeded, then it was overridden by the user. We will use it
8661 # for the tool.
8662
8663 # First remove it from the list of overridden variables, so we can test
8664 # for unknown variables in the end.
8665 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8666
8667 # Check if the provided tool contains a complete path.
8668 tool_specified="$PRINTF"
8669 tool_basename="${tool_specified##*/}"
8670 if test "x$tool_basename" = "x$tool_specified"; then
8671 # A command without a complete path is provided, search $PATH.
8672 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8673 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8674 # Extract the first word of "$tool_basename", so it can be a program name with args.
8675 set dummy $tool_basename; ac_word=$2
8676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8677 $as_echo_n "checking for $ac_word... " >&6; }
8678 if ${ac_cv_path_PRINTF+:} false; then :
8679 $as_echo_n "(cached) " >&6
8680 else
8681 case $PRINTF in
8682 [\\/]* | ?:[\\/]*)
8683 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8684 ;;
8685 *)
8686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8687 for as_dir in $PATH
8688 do
8689 IFS=$as_save_IFS
8690 test -z "$as_dir" && as_dir=.
8691 for ac_exec_ext in '' $ac_executable_extensions; do
8692 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8693 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8694 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8695 break 2
8696 fi
8697 done
8698 done
8699 IFS=$as_save_IFS
8700
8701 ;;
8702 esac
8703 fi
8704 PRINTF=$ac_cv_path_PRINTF
8705 if test -n "$PRINTF"; then
8706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8707 $as_echo "$PRINTF" >&6; }
8708 else
8709 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8710 $as_echo "no" >&6; }
8711 fi
8712
8713
8714 if test "x$PRINTF" = x; then
8715 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8716 fi
8717 else
8718 # Otherwise we believe it is a complete path. Use it as it is.
8719 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8720 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8722 $as_echo_n "checking for PRINTF... " >&6; }
8723 if test ! -x "$tool_specified"; then
8724 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8725 $as_echo "not found" >&6; }
8726 as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8727 fi
8728 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8729 $as_echo "$tool_specified" >&6; }
8730 fi
8731 fi
8732 fi
8733
8734
8735
8736 if test "x$PRINTF" = x; then
8737 as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8738 fi
8739
8740
8741
8742
8743
8744 # Publish this variable in the help.
8745
8746
8747 if test "x$RM" = x; then
8748 # The variable is not set by user, try to locate tool using the code snippet
8749 for ac_prog in rm
8750 do
8751 # Extract the first word of "$ac_prog", so it can be a program name with args.
8752 set dummy $ac_prog; ac_word=$2
8753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8754 $as_echo_n "checking for $ac_word... " >&6; }
8755 if ${ac_cv_path_RM+:} false; then :
8756 $as_echo_n "(cached) " >&6
8757 else
8758 case $RM in
8759 [\\/]* | ?:[\\/]*)
8760 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8761 ;;
8762 *)
8763 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8764 for as_dir in $PATH
8765 do
8766 IFS=$as_save_IFS
8767 test -z "$as_dir" && as_dir=.
8768 for ac_exec_ext in '' $ac_executable_extensions; do
8769 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8770 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8771 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8772 break 2
8773 fi
8774 done
8775 done
8776 IFS=$as_save_IFS
8777
8778 ;;
8779 esac
8780 fi
8781 RM=$ac_cv_path_RM
8782 if test -n "$RM"; then
8783 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8784 $as_echo "$RM" >&6; }
8785 else
8786 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8787 $as_echo "no" >&6; }
8788 fi
8789
8790
8791 test -n "$RM" && break
8792 done
8793
8794 else
8795 # The variable is set, but is it from the command line or the environment?
8796
8797 # Try to remove the string !RM! from our list.
8798 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8799 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8800 # If it failed, the variable was not from the command line. Ignore it,
8801 # but warn the user (except for BASH, which is always set by the calling BASH).
8802 if test "xRM" != xBASH; then
8803 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8804 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8805 fi
8806 # Try to locate tool using the code snippet
8807 for ac_prog in rm
8808 do
8809 # Extract the first word of "$ac_prog", so it can be a program name with args.
8810 set dummy $ac_prog; ac_word=$2
8811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8812 $as_echo_n "checking for $ac_word... " >&6; }
8813 if ${ac_cv_path_RM+:} false; then :
8814 $as_echo_n "(cached) " >&6
8815 else
8816 case $RM in
8817 [\\/]* | ?:[\\/]*)
8818 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8819 ;;
8820 *)
8821 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8822 for as_dir in $PATH
8823 do
8824 IFS=$as_save_IFS
8825 test -z "$as_dir" && as_dir=.
8826 for ac_exec_ext in '' $ac_executable_extensions; do
8827 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8828 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8829 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8830 break 2
8831 fi
8832 done
8833 done
8834 IFS=$as_save_IFS
8835
8836 ;;
8837 esac
8838 fi
8839 RM=$ac_cv_path_RM
8840 if test -n "$RM"; then
8841 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8842 $as_echo "$RM" >&6; }
8843 else
8844 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8845 $as_echo "no" >&6; }
8846 fi
8847
8848
8849 test -n "$RM" && break
8850 done
8851
8852 else
8853 # If it succeeded, then it was overridden by the user. We will use it
8854 # for the tool.
8855
8856 # First remove it from the list of overridden variables, so we can test
8857 # for unknown variables in the end.
8858 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8859
8860 # Check if the provided tool contains a complete path.
8861 tool_specified="$RM"
8862 tool_basename="${tool_specified##*/}"
8863 if test "x$tool_basename" = "x$tool_specified"; then
8864 # A command without a complete path is provided, search $PATH.
8865 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8866 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8867 # Extract the first word of "$tool_basename", so it can be a program name with args.
8868 set dummy $tool_basename; ac_word=$2
8869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8870 $as_echo_n "checking for $ac_word... " >&6; }
8871 if ${ac_cv_path_RM+:} false; then :
8872 $as_echo_n "(cached) " >&6
8873 else
8874 case $RM in
8875 [\\/]* | ?:[\\/]*)
8876 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8877 ;;
8878 *)
8879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8880 for as_dir in $PATH
8881 do
8882 IFS=$as_save_IFS
8883 test -z "$as_dir" && as_dir=.
8884 for ac_exec_ext in '' $ac_executable_extensions; do
8885 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8886 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8887 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8888 break 2
8889 fi
8890 done
8891 done
8892 IFS=$as_save_IFS
8893
8894 ;;
8895 esac
8896 fi
8897 RM=$ac_cv_path_RM
8898 if test -n "$RM"; then
8899 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8900 $as_echo "$RM" >&6; }
8901 else
8902 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8903 $as_echo "no" >&6; }
8904 fi
8905
8906
8907 if test "x$RM" = x; then
8908 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8909 fi
8910 else
8911 # Otherwise we believe it is a complete path. Use it as it is.
8912 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
8913 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
8914 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
8915 $as_echo_n "checking for RM... " >&6; }
8916 if test ! -x "$tool_specified"; then
8917 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8918 $as_echo "not found" >&6; }
8919 as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
8920 fi
8921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8922 $as_echo "$tool_specified" >&6; }
8923 fi
8924 fi
8925 fi
8926
8927
8928
8929 if test "x$RM" = x; then
8930 as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
8931 fi
8932
8933
8934
8935
8936
8937 # Publish this variable in the help.
8938
8939
8940 if test "x$SH" = x; then
8941 # The variable is not set by user, try to locate tool using the code snippet
8942 for ac_prog in sh
8943 do
8944 # Extract the first word of "$ac_prog", so it can be a program name with args.
8945 set dummy $ac_prog; ac_word=$2
8946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8947 $as_echo_n "checking for $ac_word... " >&6; }
8948 if ${ac_cv_path_SH+:} false; then :
8949 $as_echo_n "(cached) " >&6
8950 else
8951 case $SH in
8952 [\\/]* | ?:[\\/]*)
8953 ac_cv_path_SH="$SH" # Let the user override the test with a path.
8954 ;;
8955 *)
8956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8957 for as_dir in $PATH
8958 do
8959 IFS=$as_save_IFS
8960 test -z "$as_dir" && as_dir=.
8961 for ac_exec_ext in '' $ac_executable_extensions; do
8962 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8963 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
8964 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8965 break 2
8966 fi
8967 done
8968 done
8969 IFS=$as_save_IFS
8970
8971 ;;
8972 esac
8973 fi
8974 SH=$ac_cv_path_SH
8975 if test -n "$SH"; then
8976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
8977 $as_echo "$SH" >&6; }
8978 else
8979 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8980 $as_echo "no" >&6; }
8981 fi
8982
8983
8984 test -n "$SH" && break
8985 done
8986
8987 else
8988 # The variable is set, but is it from the command line or the environment?
8989
8990 # Try to remove the string !SH! from our list.
8991 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
8992 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8993 # If it failed, the variable was not from the command line. Ignore it,
8994 # but warn the user (except for BASH, which is always set by the calling BASH).
8995 if test "xSH" != xBASH; then
8996 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
8997 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
8998 fi
8999 # Try to locate tool using the code snippet
9000 for ac_prog in sh
9001 do
9002 # Extract the first word of "$ac_prog", so it can be a program name with args.
9003 set dummy $ac_prog; ac_word=$2
9004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9005 $as_echo_n "checking for $ac_word... " >&6; }
9006 if ${ac_cv_path_SH+:} false; then :
9007 $as_echo_n "(cached) " >&6
9008 else
9009 case $SH in
9010 [\\/]* | ?:[\\/]*)
9011 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9012 ;;
9013 *)
9014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9015 for as_dir in $PATH
9016 do
9017 IFS=$as_save_IFS
9018 test -z "$as_dir" && as_dir=.
9019 for ac_exec_ext in '' $ac_executable_extensions; do
9020 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9021 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9022 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9023 break 2
9024 fi
9025 done
9026 done
9027 IFS=$as_save_IFS
9028
9029 ;;
9030 esac
9031 fi
9032 SH=$ac_cv_path_SH
9033 if test -n "$SH"; then
9034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9035 $as_echo "$SH" >&6; }
9036 else
9037 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9038 $as_echo "no" >&6; }
9039 fi
9040
9041
9042 test -n "$SH" && break
9043 done
9044
9045 else
9046 # If it succeeded, then it was overridden by the user. We will use it
9047 # for the tool.
9048
9049 # First remove it from the list of overridden variables, so we can test
9050 # for unknown variables in the end.
9051 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9052
9053 # Check if the provided tool contains a complete path.
9054 tool_specified="$SH"
9055 tool_basename="${tool_specified##*/}"
9056 if test "x$tool_basename" = "x$tool_specified"; then
9057 # A command without a complete path is provided, search $PATH.
9058 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9059 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9060 # Extract the first word of "$tool_basename", so it can be a program name with args.
9061 set dummy $tool_basename; ac_word=$2
9062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9063 $as_echo_n "checking for $ac_word... " >&6; }
9064 if ${ac_cv_path_SH+:} false; then :
9065 $as_echo_n "(cached) " >&6
9066 else
9067 case $SH in
9068 [\\/]* | ?:[\\/]*)
9069 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9070 ;;
9071 *)
9072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9073 for as_dir in $PATH
9074 do
9075 IFS=$as_save_IFS
9076 test -z "$as_dir" && as_dir=.
9077 for ac_exec_ext in '' $ac_executable_extensions; do
9078 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9079 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9080 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9081 break 2
9082 fi
9083 done
9084 done
9085 IFS=$as_save_IFS
9086
9087 ;;
9088 esac
9089 fi
9090 SH=$ac_cv_path_SH
9091 if test -n "$SH"; then
9092 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9093 $as_echo "$SH" >&6; }
9094 else
9095 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9096 $as_echo "no" >&6; }
9097 fi
9098
9099
9100 if test "x$SH" = x; then
9101 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9102 fi
9103 else
9104 # Otherwise we believe it is a complete path. Use it as it is.
9105 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9106 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9107 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9108 $as_echo_n "checking for SH... " >&6; }
9109 if test ! -x "$tool_specified"; then
9110 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9111 $as_echo "not found" >&6; }
9112 as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9113 fi
9114 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9115 $as_echo "$tool_specified" >&6; }
9116 fi
9117 fi
9118 fi
9119
9120
9121
9122 if test "x$SH" = x; then
9123 as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9124 fi
9125
9126
9127
9128
9129
9130 # Publish this variable in the help.
9131
9132
9133 if test "x$SORT" = x; then
9134 # The variable is not set by user, try to locate tool using the code snippet
9135 for ac_prog in sort
9136 do
9137 # Extract the first word of "$ac_prog", so it can be a program name with args.
9138 set dummy $ac_prog; ac_word=$2
9139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9140 $as_echo_n "checking for $ac_word... " >&6; }
9141 if ${ac_cv_path_SORT+:} false; then :
9142 $as_echo_n "(cached) " >&6
9143 else
9144 case $SORT in
9145 [\\/]* | ?:[\\/]*)
9146 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9147 ;;
9148 *)
9149 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9150 for as_dir in $PATH
9151 do
9152 IFS=$as_save_IFS
9153 test -z "$as_dir" && as_dir=.
9154 for ac_exec_ext in '' $ac_executable_extensions; do
9155 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9156 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9157 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9158 break 2
9159 fi
9160 done
9161 done
9162 IFS=$as_save_IFS
9163
9164 ;;
9165 esac
9166 fi
9167 SORT=$ac_cv_path_SORT
9168 if test -n "$SORT"; then
9169 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9170 $as_echo "$SORT" >&6; }
9171 else
9172 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9173 $as_echo "no" >&6; }
9174 fi
9175
9176
9177 test -n "$SORT" && break
9178 done
9179
9180 else
9181 # The variable is set, but is it from the command line or the environment?
9182
9183 # Try to remove the string !SORT! from our list.
9184 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9185 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9186 # If it failed, the variable was not from the command line. Ignore it,
9187 # but warn the user (except for BASH, which is always set by the calling BASH).
9188 if test "xSORT" != xBASH; then
9189 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9190 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9191 fi
9192 # Try to locate tool using the code snippet
9193 for ac_prog in sort
9194 do
9195 # Extract the first word of "$ac_prog", so it can be a program name with args.
9196 set dummy $ac_prog; ac_word=$2
9197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9198 $as_echo_n "checking for $ac_word... " >&6; }
9199 if ${ac_cv_path_SORT+:} false; then :
9200 $as_echo_n "(cached) " >&6
9201 else
9202 case $SORT in
9203 [\\/]* | ?:[\\/]*)
9204 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9205 ;;
9206 *)
9207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9208 for as_dir in $PATH
9209 do
9210 IFS=$as_save_IFS
9211 test -z "$as_dir" && as_dir=.
9212 for ac_exec_ext in '' $ac_executable_extensions; do
9213 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9214 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9215 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9216 break 2
9217 fi
9218 done
9219 done
9220 IFS=$as_save_IFS
9221
9222 ;;
9223 esac
9224 fi
9225 SORT=$ac_cv_path_SORT
9226 if test -n "$SORT"; then
9227 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9228 $as_echo "$SORT" >&6; }
9229 else
9230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9231 $as_echo "no" >&6; }
9232 fi
9233
9234
9235 test -n "$SORT" && break
9236 done
9237
9238 else
9239 # If it succeeded, then it was overridden by the user. We will use it
9240 # for the tool.
9241
9242 # First remove it from the list of overridden variables, so we can test
9243 # for unknown variables in the end.
9244 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9245
9246 # Check if the provided tool contains a complete path.
9247 tool_specified="$SORT"
9248 tool_basename="${tool_specified##*/}"
9249 if test "x$tool_basename" = "x$tool_specified"; then
9250 # A command without a complete path is provided, search $PATH.
9251 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9252 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9253 # Extract the first word of "$tool_basename", so it can be a program name with args.
9254 set dummy $tool_basename; ac_word=$2
9255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9256 $as_echo_n "checking for $ac_word... " >&6; }
9257 if ${ac_cv_path_SORT+:} false; then :
9258 $as_echo_n "(cached) " >&6
9259 else
9260 case $SORT in
9261 [\\/]* | ?:[\\/]*)
9262 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9263 ;;
9264 *)
9265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9266 for as_dir in $PATH
9267 do
9268 IFS=$as_save_IFS
9269 test -z "$as_dir" && as_dir=.
9270 for ac_exec_ext in '' $ac_executable_extensions; do
9271 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9272 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9273 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9274 break 2
9275 fi
9276 done
9277 done
9278 IFS=$as_save_IFS
9279
9280 ;;
9281 esac
9282 fi
9283 SORT=$ac_cv_path_SORT
9284 if test -n "$SORT"; then
9285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9286 $as_echo "$SORT" >&6; }
9287 else
9288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9289 $as_echo "no" >&6; }
9290 fi
9291
9292
9293 if test "x$SORT" = x; then
9294 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9295 fi
9296 else
9297 # Otherwise we believe it is a complete path. Use it as it is.
9298 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9299 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9300 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9301 $as_echo_n "checking for SORT... " >&6; }
9302 if test ! -x "$tool_specified"; then
9303 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9304 $as_echo "not found" >&6; }
9305 as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9306 fi
9307 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9308 $as_echo "$tool_specified" >&6; }
9309 fi
9310 fi
9311 fi
9312
9313
9314
9315 if test "x$SORT" = x; then
9316 as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9317 fi
9318
9319
9320
9321
9322
9323 # Publish this variable in the help.
9324
9325
9326 if test "x$TAIL" = x; then
9327 # The variable is not set by user, try to locate tool using the code snippet
9328 for ac_prog in tail
9329 do
9330 # Extract the first word of "$ac_prog", so it can be a program name with args.
9331 set dummy $ac_prog; ac_word=$2
9332 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9333 $as_echo_n "checking for $ac_word... " >&6; }
9334 if ${ac_cv_path_TAIL+:} false; then :
9335 $as_echo_n "(cached) " >&6
9336 else
9337 case $TAIL in
9338 [\\/]* | ?:[\\/]*)
9339 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9340 ;;
9341 *)
9342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9343 for as_dir in $PATH
9344 do
9345 IFS=$as_save_IFS
9346 test -z "$as_dir" && as_dir=.
9347 for ac_exec_ext in '' $ac_executable_extensions; do
9348 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9349 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9350 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9351 break 2
9352 fi
9353 done
9354 done
9355 IFS=$as_save_IFS
9356
9357 ;;
9358 esac
9359 fi
9360 TAIL=$ac_cv_path_TAIL
9361 if test -n "$TAIL"; then
9362 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9363 $as_echo "$TAIL" >&6; }
9364 else
9365 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9366 $as_echo "no" >&6; }
9367 fi
9368
9369
9370 test -n "$TAIL" && break
9371 done
9372
9373 else
9374 # The variable is set, but is it from the command line or the environment?
9375
9376 # Try to remove the string !TAIL! from our list.
9377 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9378 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9379 # If it failed, the variable was not from the command line. Ignore it,
9380 # but warn the user (except for BASH, which is always set by the calling BASH).
9381 if test "xTAIL" != xBASH; then
9382 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9383 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9384 fi
9385 # Try to locate tool using the code snippet
9386 for ac_prog in tail
9387 do
9388 # Extract the first word of "$ac_prog", so it can be a program name with args.
9389 set dummy $ac_prog; ac_word=$2
9390 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9391 $as_echo_n "checking for $ac_word... " >&6; }
9392 if ${ac_cv_path_TAIL+:} false; then :
9393 $as_echo_n "(cached) " >&6
9394 else
9395 case $TAIL in
9396 [\\/]* | ?:[\\/]*)
9397 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9398 ;;
9399 *)
9400 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9401 for as_dir in $PATH
9402 do
9403 IFS=$as_save_IFS
9404 test -z "$as_dir" && as_dir=.
9405 for ac_exec_ext in '' $ac_executable_extensions; do
9406 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9407 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9408 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9409 break 2
9410 fi
9411 done
9412 done
9413 IFS=$as_save_IFS
9414
9415 ;;
9416 esac
9417 fi
9418 TAIL=$ac_cv_path_TAIL
9419 if test -n "$TAIL"; then
9420 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9421 $as_echo "$TAIL" >&6; }
9422 else
9423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9424 $as_echo "no" >&6; }
9425 fi
9426
9427
9428 test -n "$TAIL" && break
9429 done
9430
9431 else
9432 # If it succeeded, then it was overridden by the user. We will use it
9433 # for the tool.
9434
9435 # First remove it from the list of overridden variables, so we can test
9436 # for unknown variables in the end.
9437 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9438
9439 # Check if the provided tool contains a complete path.
9440 tool_specified="$TAIL"
9441 tool_basename="${tool_specified##*/}"
9442 if test "x$tool_basename" = "x$tool_specified"; then
9443 # A command without a complete path is provided, search $PATH.
9444 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9445 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9446 # Extract the first word of "$tool_basename", so it can be a program name with args.
9447 set dummy $tool_basename; ac_word=$2
9448 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9449 $as_echo_n "checking for $ac_word... " >&6; }
9450 if ${ac_cv_path_TAIL+:} false; then :
9451 $as_echo_n "(cached) " >&6
9452 else
9453 case $TAIL in
9454 [\\/]* | ?:[\\/]*)
9455 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9456 ;;
9457 *)
9458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9459 for as_dir in $PATH
9460 do
9461 IFS=$as_save_IFS
9462 test -z "$as_dir" && as_dir=.
9463 for ac_exec_ext in '' $ac_executable_extensions; do
9464 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9465 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9466 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9467 break 2
9468 fi
9469 done
9470 done
9471 IFS=$as_save_IFS
9472
9473 ;;
9474 esac
9475 fi
9476 TAIL=$ac_cv_path_TAIL
9477 if test -n "$TAIL"; then
9478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9479 $as_echo "$TAIL" >&6; }
9480 else
9481 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9482 $as_echo "no" >&6; }
9483 fi
9484
9485
9486 if test "x$TAIL" = x; then
9487 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9488 fi
9489 else
9490 # Otherwise we believe it is a complete path. Use it as it is.
9491 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9492 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9493 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9494 $as_echo_n "checking for TAIL... " >&6; }
9495 if test ! -x "$tool_specified"; then
9496 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9497 $as_echo "not found" >&6; }
9498 as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9499 fi
9500 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9501 $as_echo "$tool_specified" >&6; }
9502 fi
9503 fi
9504 fi
9505
9506
9507
9508 if test "x$TAIL" = x; then
9509 as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9510 fi
9511
9512
9513
9514
9515
9516 # Publish this variable in the help.
9517
9518
9519 if test "x$TAR" = x; then
9520 # The variable is not set by user, try to locate tool using the code snippet
9521 for ac_prog in tar
9522 do
9523 # Extract the first word of "$ac_prog", so it can be a program name with args.
9524 set dummy $ac_prog; ac_word=$2
9525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9526 $as_echo_n "checking for $ac_word... " >&6; }
9527 if ${ac_cv_path_TAR+:} false; then :
9528 $as_echo_n "(cached) " >&6
9529 else
9530 case $TAR in
9531 [\\/]* | ?:[\\/]*)
9532 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9533 ;;
9534 *)
9535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9536 for as_dir in $PATH
9537 do
9538 IFS=$as_save_IFS
9539 test -z "$as_dir" && as_dir=.
9540 for ac_exec_ext in '' $ac_executable_extensions; do
9541 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9542 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9543 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9544 break 2
9545 fi
9546 done
9547 done
9548 IFS=$as_save_IFS
9549
9550 ;;
9551 esac
9552 fi
9553 TAR=$ac_cv_path_TAR
9554 if test -n "$TAR"; then
9555 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9556 $as_echo "$TAR" >&6; }
9557 else
9558 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9559 $as_echo "no" >&6; }
9560 fi
9561
9562
9563 test -n "$TAR" && break
9564 done
9565
9566 else
9567 # The variable is set, but is it from the command line or the environment?
9568
9569 # Try to remove the string !TAR! from our list.
9570 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9571 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9572 # If it failed, the variable was not from the command line. Ignore it,
9573 # but warn the user (except for BASH, which is always set by the calling BASH).
9574 if test "xTAR" != xBASH; then
9575 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9576 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9577 fi
9578 # Try to locate tool using the code snippet
9579 for ac_prog in tar
9580 do
9581 # Extract the first word of "$ac_prog", so it can be a program name with args.
9582 set dummy $ac_prog; ac_word=$2
9583 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9584 $as_echo_n "checking for $ac_word... " >&6; }
9585 if ${ac_cv_path_TAR+:} false; then :
9586 $as_echo_n "(cached) " >&6
9587 else
9588 case $TAR in
9589 [\\/]* | ?:[\\/]*)
9590 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9591 ;;
9592 *)
9593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9594 for as_dir in $PATH
9595 do
9596 IFS=$as_save_IFS
9597 test -z "$as_dir" && as_dir=.
9598 for ac_exec_ext in '' $ac_executable_extensions; do
9599 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9600 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9601 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9602 break 2
9603 fi
9604 done
9605 done
9606 IFS=$as_save_IFS
9607
9608 ;;
9609 esac
9610 fi
9611 TAR=$ac_cv_path_TAR
9612 if test -n "$TAR"; then
9613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9614 $as_echo "$TAR" >&6; }
9615 else
9616 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9617 $as_echo "no" >&6; }
9618 fi
9619
9620
9621 test -n "$TAR" && break
9622 done
9623
9624 else
9625 # If it succeeded, then it was overridden by the user. We will use it
9626 # for the tool.
9627
9628 # First remove it from the list of overridden variables, so we can test
9629 # for unknown variables in the end.
9630 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9631
9632 # Check if the provided tool contains a complete path.
9633 tool_specified="$TAR"
9634 tool_basename="${tool_specified##*/}"
9635 if test "x$tool_basename" = "x$tool_specified"; then
9636 # A command without a complete path is provided, search $PATH.
9637 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9638 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9639 # Extract the first word of "$tool_basename", so it can be a program name with args.
9640 set dummy $tool_basename; ac_word=$2
9641 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9642 $as_echo_n "checking for $ac_word... " >&6; }
9643 if ${ac_cv_path_TAR+:} false; then :
9644 $as_echo_n "(cached) " >&6
9645 else
9646 case $TAR in
9647 [\\/]* | ?:[\\/]*)
9648 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9649 ;;
9650 *)
9651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9652 for as_dir in $PATH
9653 do
9654 IFS=$as_save_IFS
9655 test -z "$as_dir" && as_dir=.
9656 for ac_exec_ext in '' $ac_executable_extensions; do
9657 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9658 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9659 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9660 break 2
9661 fi
9662 done
9663 done
9664 IFS=$as_save_IFS
9665
9666 ;;
9667 esac
9668 fi
9669 TAR=$ac_cv_path_TAR
9670 if test -n "$TAR"; then
9671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9672 $as_echo "$TAR" >&6; }
9673 else
9674 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9675 $as_echo "no" >&6; }
9676 fi
9677
9678
9679 if test "x$TAR" = x; then
9680 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9681 fi
9682 else
9683 # Otherwise we believe it is a complete path. Use it as it is.
9684 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9685 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9686 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9687 $as_echo_n "checking for TAR... " >&6; }
9688 if test ! -x "$tool_specified"; then
9689 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9690 $as_echo "not found" >&6; }
9691 as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9692 fi
9693 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9694 $as_echo "$tool_specified" >&6; }
9695 fi
9696 fi
9697 fi
9698
9699
9700
9701 if test "x$TAR" = x; then
9702 as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9703 fi
9704
9705
9706
9707
9708
9709 # Publish this variable in the help.
9710
9711
9712 if test "x$TEE" = x; then
9713 # The variable is not set by user, try to locate tool using the code snippet
9714 for ac_prog in tee
9715 do
9716 # Extract the first word of "$ac_prog", so it can be a program name with args.
9717 set dummy $ac_prog; ac_word=$2
9718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9719 $as_echo_n "checking for $ac_word... " >&6; }
9720 if ${ac_cv_path_TEE+:} false; then :
9721 $as_echo_n "(cached) " >&6
9722 else
9723 case $TEE in
9724 [\\/]* | ?:[\\/]*)
9725 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9726 ;;
9727 *)
9728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9729 for as_dir in $PATH
9730 do
9731 IFS=$as_save_IFS
9732 test -z "$as_dir" && as_dir=.
9733 for ac_exec_ext in '' $ac_executable_extensions; do
9734 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9735 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9736 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9737 break 2
9738 fi
9739 done
9740 done
9741 IFS=$as_save_IFS
9742
9743 ;;
9744 esac
9745 fi
9746 TEE=$ac_cv_path_TEE
9747 if test -n "$TEE"; then
9748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9749 $as_echo "$TEE" >&6; }
9750 else
9751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9752 $as_echo "no" >&6; }
9753 fi
9754
9755
9756 test -n "$TEE" && break
9757 done
9758
9759 else
9760 # The variable is set, but is it from the command line or the environment?
9761
9762 # Try to remove the string !TEE! from our list.
9763 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9764 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9765 # If it failed, the variable was not from the command line. Ignore it,
9766 # but warn the user (except for BASH, which is always set by the calling BASH).
9767 if test "xTEE" != xBASH; then
9768 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9769 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9770 fi
9771 # Try to locate tool using the code snippet
9772 for ac_prog in tee
9773 do
9774 # Extract the first word of "$ac_prog", so it can be a program name with args.
9775 set dummy $ac_prog; ac_word=$2
9776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9777 $as_echo_n "checking for $ac_word... " >&6; }
9778 if ${ac_cv_path_TEE+:} false; then :
9779 $as_echo_n "(cached) " >&6
9780 else
9781 case $TEE in
9782 [\\/]* | ?:[\\/]*)
9783 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9784 ;;
9785 *)
9786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9787 for as_dir in $PATH
9788 do
9789 IFS=$as_save_IFS
9790 test -z "$as_dir" && as_dir=.
9791 for ac_exec_ext in '' $ac_executable_extensions; do
9792 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9793 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9794 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9795 break 2
9796 fi
9797 done
9798 done
9799 IFS=$as_save_IFS
9800
9801 ;;
9802 esac
9803 fi
9804 TEE=$ac_cv_path_TEE
9805 if test -n "$TEE"; then
9806 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9807 $as_echo "$TEE" >&6; }
9808 else
9809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9810 $as_echo "no" >&6; }
9811 fi
9812
9813
9814 test -n "$TEE" && break
9815 done
9816
9817 else
9818 # If it succeeded, then it was overridden by the user. We will use it
9819 # for the tool.
9820
9821 # First remove it from the list of overridden variables, so we can test
9822 # for unknown variables in the end.
9823 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9824
9825 # Check if the provided tool contains a complete path.
9826 tool_specified="$TEE"
9827 tool_basename="${tool_specified##*/}"
9828 if test "x$tool_basename" = "x$tool_specified"; then
9829 # A command without a complete path is provided, search $PATH.
9830 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9831 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9832 # Extract the first word of "$tool_basename", so it can be a program name with args.
9833 set dummy $tool_basename; ac_word=$2
9834 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9835 $as_echo_n "checking for $ac_word... " >&6; }
9836 if ${ac_cv_path_TEE+:} false; then :
9837 $as_echo_n "(cached) " >&6
9838 else
9839 case $TEE in
9840 [\\/]* | ?:[\\/]*)
9841 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9842 ;;
9843 *)
9844 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9845 for as_dir in $PATH
9846 do
9847 IFS=$as_save_IFS
9848 test -z "$as_dir" && as_dir=.
9849 for ac_exec_ext in '' $ac_executable_extensions; do
9850 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9851 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9852 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9853 break 2
9854 fi
9855 done
9856 done
9857 IFS=$as_save_IFS
9858
9859 ;;
9860 esac
9861 fi
9862 TEE=$ac_cv_path_TEE
9863 if test -n "$TEE"; then
9864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9865 $as_echo "$TEE" >&6; }
9866 else
9867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9868 $as_echo "no" >&6; }
9869 fi
9870
9871
9872 if test "x$TEE" = x; then
9873 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9874 fi
9875 else
9876 # Otherwise we believe it is a complete path. Use it as it is.
9877 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
9878 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
9879 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
9880 $as_echo_n "checking for TEE... " >&6; }
9881 if test ! -x "$tool_specified"; then
9882 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9883 $as_echo "not found" >&6; }
9884 as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
9885 fi
9886 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9887 $as_echo "$tool_specified" >&6; }
9888 fi
9889 fi
9890 fi
9891
9892
9893
9894 if test "x$TEE" = x; then
9895 as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
9896 fi
9897
9898
9899
9900
9901
9902 # Publish this variable in the help.
9903
9904
9905 if test "x$TOUCH" = x; then
9906 # The variable is not set by user, try to locate tool using the code snippet
9907 for ac_prog in touch
9908 do
9909 # Extract the first word of "$ac_prog", so it can be a program name with args.
9910 set dummy $ac_prog; ac_word=$2
9911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9912 $as_echo_n "checking for $ac_word... " >&6; }
9913 if ${ac_cv_path_TOUCH+:} false; then :
9914 $as_echo_n "(cached) " >&6
9915 else
9916 case $TOUCH in
9917 [\\/]* | ?:[\\/]*)
9918 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
9919 ;;
9920 *)
9921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9922 for as_dir in $PATH
9923 do
9924 IFS=$as_save_IFS
9925 test -z "$as_dir" && as_dir=.
9926 for ac_exec_ext in '' $ac_executable_extensions; do
9927 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9928 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
9929 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9930 break 2
9931 fi
9932 done
9933 done
9934 IFS=$as_save_IFS
9935
9936 ;;
9937 esac
9938 fi
9939 TOUCH=$ac_cv_path_TOUCH
9940 if test -n "$TOUCH"; then
9941 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
9942 $as_echo "$TOUCH" >&6; }
9943 else
9944 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9945 $as_echo "no" >&6; }
9946 fi
9947
9948
9949 test -n "$TOUCH" && break
9950 done
9951
9952 else
9953 # The variable is set, but is it from the command line or the environment?
9954
9955 # Try to remove the string !TOUCH! from our list.
9956 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
9957 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9958 # If it failed, the variable was not from the command line. Ignore it,
9959 # but warn the user (except for BASH, which is always set by the calling BASH).
9960 if test "xTOUCH" != xBASH; then
9961 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
9962 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
9963 fi
9964 # Try to locate tool using the code snippet
9965 for ac_prog in touch
9966 do
9967 # Extract the first word of "$ac_prog", so it can be a program name with args.
9968 set dummy $ac_prog; ac_word=$2
9969 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9970 $as_echo_n "checking for $ac_word... " >&6; }
9971 if ${ac_cv_path_TOUCH+:} false; then :
9972 $as_echo_n "(cached) " >&6
9973 else
9974 case $TOUCH in
9975 [\\/]* | ?:[\\/]*)
9976 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
9977 ;;
9978 *)
9979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9980 for as_dir in $PATH
9981 do
9982 IFS=$as_save_IFS
9983 test -z "$as_dir" && as_dir=.
9984 for ac_exec_ext in '' $ac_executable_extensions; do
9985 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9986 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
9987 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9988 break 2
9989 fi
9990 done
9991 done
9992 IFS=$as_save_IFS
9993
9994 ;;
9995 esac
9996 fi
9997 TOUCH=$ac_cv_path_TOUCH
9998 if test -n "$TOUCH"; then
9999 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10000 $as_echo "$TOUCH" >&6; }
10001 else
10002 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10003 $as_echo "no" >&6; }
10004 fi
10005
10006
10007 test -n "$TOUCH" && break
10008 done
10009
10010 else
10011 # If it succeeded, then it was overridden by the user. We will use it
10012 # for the tool.
10013
10014 # First remove it from the list of overridden variables, so we can test
10015 # for unknown variables in the end.
10016 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10017
10018 # Check if the provided tool contains a complete path.
10019 tool_specified="$TOUCH"
10020 tool_basename="${tool_specified##*/}"
10021 if test "x$tool_basename" = "x$tool_specified"; then
10022 # A command without a complete path is provided, search $PATH.
10023 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10024 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10025 # Extract the first word of "$tool_basename", so it can be a program name with args.
10026 set dummy $tool_basename; ac_word=$2
10027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10028 $as_echo_n "checking for $ac_word... " >&6; }
10029 if ${ac_cv_path_TOUCH+:} false; then :
10030 $as_echo_n "(cached) " >&6
10031 else
10032 case $TOUCH in
10033 [\\/]* | ?:[\\/]*)
10034 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10035 ;;
10036 *)
10037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10038 for as_dir in $PATH
10039 do
10040 IFS=$as_save_IFS
10041 test -z "$as_dir" && as_dir=.
10042 for ac_exec_ext in '' $ac_executable_extensions; do
10043 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10044 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10045 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10046 break 2
10047 fi
10048 done
10049 done
10050 IFS=$as_save_IFS
10051
10052 ;;
10053 esac
10054 fi
10055 TOUCH=$ac_cv_path_TOUCH
10056 if test -n "$TOUCH"; then
10057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10058 $as_echo "$TOUCH" >&6; }
10059 else
10060 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10061 $as_echo "no" >&6; }
10062 fi
10063
10064
10065 if test "x$TOUCH" = x; then
10066 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10067 fi
10068 else
10069 # Otherwise we believe it is a complete path. Use it as it is.
10070 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10071 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10072 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10073 $as_echo_n "checking for TOUCH... " >&6; }
10074 if test ! -x "$tool_specified"; then
10075 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10076 $as_echo "not found" >&6; }
10077 as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10078 fi
10079 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10080 $as_echo "$tool_specified" >&6; }
10081 fi
10082 fi
10083 fi
10084
10085
10086
10087 if test "x$TOUCH" = x; then
10088 as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10089 fi
10090
10091
10092
10093
10094
10095 # Publish this variable in the help.
10096
10097
10098 if test "x$TR" = x; then
10099 # The variable is not set by user, try to locate tool using the code snippet
10100 for ac_prog in tr
10101 do
10102 # Extract the first word of "$ac_prog", so it can be a program name with args.
10103 set dummy $ac_prog; ac_word=$2
10104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10105 $as_echo_n "checking for $ac_word... " >&6; }
10106 if ${ac_cv_path_TR+:} false; then :
10107 $as_echo_n "(cached) " >&6
10108 else
10109 case $TR in
10110 [\\/]* | ?:[\\/]*)
10111 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10112 ;;
10113 *)
10114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10115 for as_dir in $PATH
10116 do
10117 IFS=$as_save_IFS
10118 test -z "$as_dir" && as_dir=.
10119 for ac_exec_ext in '' $ac_executable_extensions; do
10120 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10121 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10122 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10123 break 2
10124 fi
10125 done
10126 done
10127 IFS=$as_save_IFS
10128
10129 ;;
10130 esac
10131 fi
10132 TR=$ac_cv_path_TR
10133 if test -n "$TR"; then
10134 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10135 $as_echo "$TR" >&6; }
10136 else
10137 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10138 $as_echo "no" >&6; }
10139 fi
10140
10141
10142 test -n "$TR" && break
10143 done
10144
10145 else
10146 # The variable is set, but is it from the command line or the environment?
10147
10148 # Try to remove the string !TR! from our list.
10149 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10150 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10151 # If it failed, the variable was not from the command line. Ignore it,
10152 # but warn the user (except for BASH, which is always set by the calling BASH).
10153 if test "xTR" != xBASH; then
10154 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10155 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10156 fi
10157 # Try to locate tool using the code snippet
10158 for ac_prog in tr
10159 do
10160 # Extract the first word of "$ac_prog", so it can be a program name with args.
10161 set dummy $ac_prog; ac_word=$2
10162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10163 $as_echo_n "checking for $ac_word... " >&6; }
10164 if ${ac_cv_path_TR+:} false; then :
10165 $as_echo_n "(cached) " >&6
10166 else
10167 case $TR in
10168 [\\/]* | ?:[\\/]*)
10169 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10170 ;;
10171 *)
10172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10173 for as_dir in $PATH
10174 do
10175 IFS=$as_save_IFS
10176 test -z "$as_dir" && as_dir=.
10177 for ac_exec_ext in '' $ac_executable_extensions; do
10178 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10179 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10180 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10181 break 2
10182 fi
10183 done
10184 done
10185 IFS=$as_save_IFS
10186
10187 ;;
10188 esac
10189 fi
10190 TR=$ac_cv_path_TR
10191 if test -n "$TR"; then
10192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10193 $as_echo "$TR" >&6; }
10194 else
10195 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10196 $as_echo "no" >&6; }
10197 fi
10198
10199
10200 test -n "$TR" && break
10201 done
10202
10203 else
10204 # If it succeeded, then it was overridden by the user. We will use it
10205 # for the tool.
10206
10207 # First remove it from the list of overridden variables, so we can test
10208 # for unknown variables in the end.
10209 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10210
10211 # Check if the provided tool contains a complete path.
10212 tool_specified="$TR"
10213 tool_basename="${tool_specified##*/}"
10214 if test "x$tool_basename" = "x$tool_specified"; then
10215 # A command without a complete path is provided, search $PATH.
10216 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10217 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10218 # Extract the first word of "$tool_basename", so it can be a program name with args.
10219 set dummy $tool_basename; ac_word=$2
10220 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10221 $as_echo_n "checking for $ac_word... " >&6; }
10222 if ${ac_cv_path_TR+:} false; then :
10223 $as_echo_n "(cached) " >&6
10224 else
10225 case $TR in
10226 [\\/]* | ?:[\\/]*)
10227 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10228 ;;
10229 *)
10230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10231 for as_dir in $PATH
10232 do
10233 IFS=$as_save_IFS
10234 test -z "$as_dir" && as_dir=.
10235 for ac_exec_ext in '' $ac_executable_extensions; do
10236 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10237 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10238 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10239 break 2
10240 fi
10241 done
10242 done
10243 IFS=$as_save_IFS
10244
10245 ;;
10246 esac
10247 fi
10248 TR=$ac_cv_path_TR
10249 if test -n "$TR"; then
10250 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10251 $as_echo "$TR" >&6; }
10252 else
10253 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10254 $as_echo "no" >&6; }
10255 fi
10256
10257
10258 if test "x$TR" = x; then
10259 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10260 fi
10261 else
10262 # Otherwise we believe it is a complete path. Use it as it is.
10263 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10264 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10265 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10266 $as_echo_n "checking for TR... " >&6; }
10267 if test ! -x "$tool_specified"; then
10268 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10269 $as_echo "not found" >&6; }
10270 as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10271 fi
10272 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10273 $as_echo "$tool_specified" >&6; }
10274 fi
10275 fi
10276 fi
10277
10278
10279
10280 if test "x$TR" = x; then
10281 as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10282 fi
10283
10284
10285
10286
10287
10288 # Publish this variable in the help.
10289
10290
10291 if test "x$UNAME" = x; then
10292 # The variable is not set by user, try to locate tool using the code snippet
10293 for ac_prog in uname
10294 do
10295 # Extract the first word of "$ac_prog", so it can be a program name with args.
10296 set dummy $ac_prog; ac_word=$2
10297 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10298 $as_echo_n "checking for $ac_word... " >&6; }
10299 if ${ac_cv_path_UNAME+:} false; then :
10300 $as_echo_n "(cached) " >&6
10301 else
10302 case $UNAME in
10303 [\\/]* | ?:[\\/]*)
10304 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10305 ;;
10306 *)
10307 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10308 for as_dir in $PATH
10309 do
10310 IFS=$as_save_IFS
10311 test -z "$as_dir" && as_dir=.
10312 for ac_exec_ext in '' $ac_executable_extensions; do
10313 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10314 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10315 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10316 break 2
10317 fi
10318 done
10319 done
10320 IFS=$as_save_IFS
10321
10322 ;;
10323 esac
10324 fi
10325 UNAME=$ac_cv_path_UNAME
10326 if test -n "$UNAME"; then
10327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10328 $as_echo "$UNAME" >&6; }
10329 else
10330 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10331 $as_echo "no" >&6; }
10332 fi
10333
10334
10335 test -n "$UNAME" && break
10336 done
10337
10338 else
10339 # The variable is set, but is it from the command line or the environment?
10340
10341 # Try to remove the string !UNAME! from our list.
10342 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10343 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10344 # If it failed, the variable was not from the command line. Ignore it,
10345 # but warn the user (except for BASH, which is always set by the calling BASH).
10346 if test "xUNAME" != xBASH; then
10347 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10348 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10349 fi
10350 # Try to locate tool using the code snippet
10351 for ac_prog in uname
10352 do
10353 # Extract the first word of "$ac_prog", so it can be a program name with args.
10354 set dummy $ac_prog; ac_word=$2
10355 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10356 $as_echo_n "checking for $ac_word... " >&6; }
10357 if ${ac_cv_path_UNAME+:} false; then :
10358 $as_echo_n "(cached) " >&6
10359 else
10360 case $UNAME in
10361 [\\/]* | ?:[\\/]*)
10362 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10363 ;;
10364 *)
10365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10366 for as_dir in $PATH
10367 do
10368 IFS=$as_save_IFS
10369 test -z "$as_dir" && as_dir=.
10370 for ac_exec_ext in '' $ac_executable_extensions; do
10371 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10372 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10373 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10374 break 2
10375 fi
10376 done
10377 done
10378 IFS=$as_save_IFS
10379
10380 ;;
10381 esac
10382 fi
10383 UNAME=$ac_cv_path_UNAME
10384 if test -n "$UNAME"; then
10385 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10386 $as_echo "$UNAME" >&6; }
10387 else
10388 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10389 $as_echo "no" >&6; }
10390 fi
10391
10392
10393 test -n "$UNAME" && break
10394 done
10395
10396 else
10397 # If it succeeded, then it was overridden by the user. We will use it
10398 # for the tool.
10399
10400 # First remove it from the list of overridden variables, so we can test
10401 # for unknown variables in the end.
10402 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10403
10404 # Check if the provided tool contains a complete path.
10405 tool_specified="$UNAME"
10406 tool_basename="${tool_specified##*/}"
10407 if test "x$tool_basename" = "x$tool_specified"; then
10408 # A command without a complete path is provided, search $PATH.
10409 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10410 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10411 # Extract the first word of "$tool_basename", so it can be a program name with args.
10412 set dummy $tool_basename; ac_word=$2
10413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10414 $as_echo_n "checking for $ac_word... " >&6; }
10415 if ${ac_cv_path_UNAME+:} false; then :
10416 $as_echo_n "(cached) " >&6
10417 else
10418 case $UNAME in
10419 [\\/]* | ?:[\\/]*)
10420 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10421 ;;
10422 *)
10423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10424 for as_dir in $PATH
10425 do
10426 IFS=$as_save_IFS
10427 test -z "$as_dir" && as_dir=.
10428 for ac_exec_ext in '' $ac_executable_extensions; do
10429 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10430 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10431 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10432 break 2
10433 fi
10434 done
10435 done
10436 IFS=$as_save_IFS
10437
10438 ;;
10439 esac
10440 fi
10441 UNAME=$ac_cv_path_UNAME
10442 if test -n "$UNAME"; then
10443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10444 $as_echo "$UNAME" >&6; }
10445 else
10446 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10447 $as_echo "no" >&6; }
10448 fi
10449
10450
10451 if test "x$UNAME" = x; then
10452 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10453 fi
10454 else
10455 # Otherwise we believe it is a complete path. Use it as it is.
10456 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10457 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10459 $as_echo_n "checking for UNAME... " >&6; }
10460 if test ! -x "$tool_specified"; then
10461 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10462 $as_echo "not found" >&6; }
10463 as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10464 fi
10465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10466 $as_echo "$tool_specified" >&6; }
10467 fi
10468 fi
10469 fi
10470
10471
10472
10473 if test "x$UNAME" = x; then
10474 as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10475 fi
10476
10477
10478
10479
10480
10481 # Publish this variable in the help.
10482
10483
10484 if test "x$UNIQ" = x; then
10485 # The variable is not set by user, try to locate tool using the code snippet
10486 for ac_prog in uniq
10487 do
10488 # Extract the first word of "$ac_prog", so it can be a program name with args.
10489 set dummy $ac_prog; ac_word=$2
10490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10491 $as_echo_n "checking for $ac_word... " >&6; }
10492 if ${ac_cv_path_UNIQ+:} false; then :
10493 $as_echo_n "(cached) " >&6
10494 else
10495 case $UNIQ in
10496 [\\/]* | ?:[\\/]*)
10497 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10498 ;;
10499 *)
10500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10501 for as_dir in $PATH
10502 do
10503 IFS=$as_save_IFS
10504 test -z "$as_dir" && as_dir=.
10505 for ac_exec_ext in '' $ac_executable_extensions; do
10506 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10507 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10508 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10509 break 2
10510 fi
10511 done
10512 done
10513 IFS=$as_save_IFS
10514
10515 ;;
10516 esac
10517 fi
10518 UNIQ=$ac_cv_path_UNIQ
10519 if test -n "$UNIQ"; then
10520 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10521 $as_echo "$UNIQ" >&6; }
10522 else
10523 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10524 $as_echo "no" >&6; }
10525 fi
10526
10527
10528 test -n "$UNIQ" && break
10529 done
10530
10531 else
10532 # The variable is set, but is it from the command line or the environment?
10533
10534 # Try to remove the string !UNIQ! from our list.
10535 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10536 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10537 # If it failed, the variable was not from the command line. Ignore it,
10538 # but warn the user (except for BASH, which is always set by the calling BASH).
10539 if test "xUNIQ" != xBASH; then
10540 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10541 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10542 fi
10543 # Try to locate tool using the code snippet
10544 for ac_prog in uniq
10545 do
10546 # Extract the first word of "$ac_prog", so it can be a program name with args.
10547 set dummy $ac_prog; ac_word=$2
10548 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10549 $as_echo_n "checking for $ac_word... " >&6; }
10550 if ${ac_cv_path_UNIQ+:} false; then :
10551 $as_echo_n "(cached) " >&6
10552 else
10553 case $UNIQ in
10554 [\\/]* | ?:[\\/]*)
10555 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10556 ;;
10557 *)
10558 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10559 for as_dir in $PATH
10560 do
10561 IFS=$as_save_IFS
10562 test -z "$as_dir" && as_dir=.
10563 for ac_exec_ext in '' $ac_executable_extensions; do
10564 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10565 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10566 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10567 break 2
10568 fi
10569 done
10570 done
10571 IFS=$as_save_IFS
10572
10573 ;;
10574 esac
10575 fi
10576 UNIQ=$ac_cv_path_UNIQ
10577 if test -n "$UNIQ"; then
10578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10579 $as_echo "$UNIQ" >&6; }
10580 else
10581 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10582 $as_echo "no" >&6; }
10583 fi
10584
10585
10586 test -n "$UNIQ" && break
10587 done
10588
10589 else
10590 # If it succeeded, then it was overridden by the user. We will use it
10591 # for the tool.
10592
10593 # First remove it from the list of overridden variables, so we can test
10594 # for unknown variables in the end.
10595 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10596
10597 # Check if the provided tool contains a complete path.
10598 tool_specified="$UNIQ"
10599 tool_basename="${tool_specified##*/}"
10600 if test "x$tool_basename" = "x$tool_specified"; then
10601 # A command without a complete path is provided, search $PATH.
10602 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10603 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10604 # Extract the first word of "$tool_basename", so it can be a program name with args.
10605 set dummy $tool_basename; ac_word=$2
10606 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10607 $as_echo_n "checking for $ac_word... " >&6; }
10608 if ${ac_cv_path_UNIQ+:} false; then :
10609 $as_echo_n "(cached) " >&6
10610 else
10611 case $UNIQ in
10612 [\\/]* | ?:[\\/]*)
10613 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10614 ;;
10615 *)
10616 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10617 for as_dir in $PATH
10618 do
10619 IFS=$as_save_IFS
10620 test -z "$as_dir" && as_dir=.
10621 for ac_exec_ext in '' $ac_executable_extensions; do
10622 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10623 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10624 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10625 break 2
10626 fi
10627 done
10628 done
10629 IFS=$as_save_IFS
10630
10631 ;;
10632 esac
10633 fi
10634 UNIQ=$ac_cv_path_UNIQ
10635 if test -n "$UNIQ"; then
10636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10637 $as_echo "$UNIQ" >&6; }
10638 else
10639 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10640 $as_echo "no" >&6; }
10641 fi
10642
10643
10644 if test "x$UNIQ" = x; then
10645 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10646 fi
10647 else
10648 # Otherwise we believe it is a complete path. Use it as it is.
10649 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10650 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10651 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10652 $as_echo_n "checking for UNIQ... " >&6; }
10653 if test ! -x "$tool_specified"; then
10654 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10655 $as_echo "not found" >&6; }
10656 as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10657 fi
10658 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10659 $as_echo "$tool_specified" >&6; }
10660 fi
10661 fi
10662 fi
10663
10664
10665
10666 if test "x$UNIQ" = x; then
10667 as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10668 fi
10669
10670
10671
10672
10673
10674 # Publish this variable in the help.
10675
10676
10677 if test "x$WC" = x; then
10678 # The variable is not set by user, try to locate tool using the code snippet
10679 for ac_prog in wc
10680 do
10681 # Extract the first word of "$ac_prog", so it can be a program name with args.
10682 set dummy $ac_prog; ac_word=$2
10683 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10684 $as_echo_n "checking for $ac_word... " >&6; }
10685 if ${ac_cv_path_WC+:} false; then :
10686 $as_echo_n "(cached) " >&6
10687 else
10688 case $WC in
10689 [\\/]* | ?:[\\/]*)
10690 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10691 ;;
10692 *)
10693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10694 for as_dir in $PATH
10695 do
10696 IFS=$as_save_IFS
10697 test -z "$as_dir" && as_dir=.
10698 for ac_exec_ext in '' $ac_executable_extensions; do
10699 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10700 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10701 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10702 break 2
10703 fi
10704 done
10705 done
10706 IFS=$as_save_IFS
10707
10708 ;;
10709 esac
10710 fi
10711 WC=$ac_cv_path_WC
10712 if test -n "$WC"; then
10713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10714 $as_echo "$WC" >&6; }
10715 else
10716 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10717 $as_echo "no" >&6; }
10718 fi
10719
10720
10721 test -n "$WC" && break
10722 done
10723
10724 else
10725 # The variable is set, but is it from the command line or the environment?
10726
10727 # Try to remove the string !WC! from our list.
10728 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10729 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10730 # If it failed, the variable was not from the command line. Ignore it,
10731 # but warn the user (except for BASH, which is always set by the calling BASH).
10732 if test "xWC" != xBASH; then
10733 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10734 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10735 fi
10736 # Try to locate tool using the code snippet
10737 for ac_prog in wc
10738 do
10739 # Extract the first word of "$ac_prog", so it can be a program name with args.
10740 set dummy $ac_prog; ac_word=$2
10741 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10742 $as_echo_n "checking for $ac_word... " >&6; }
10743 if ${ac_cv_path_WC+:} false; then :
10744 $as_echo_n "(cached) " >&6
10745 else
10746 case $WC in
10747 [\\/]* | ?:[\\/]*)
10748 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10749 ;;
10750 *)
10751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10752 for as_dir in $PATH
10753 do
10754 IFS=$as_save_IFS
10755 test -z "$as_dir" && as_dir=.
10756 for ac_exec_ext in '' $ac_executable_extensions; do
10757 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10758 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10759 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10760 break 2
10761 fi
10762 done
10763 done
10764 IFS=$as_save_IFS
10765
10766 ;;
10767 esac
10768 fi
10769 WC=$ac_cv_path_WC
10770 if test -n "$WC"; then
10771 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10772 $as_echo "$WC" >&6; }
10773 else
10774 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10775 $as_echo "no" >&6; }
10776 fi
10777
10778
10779 test -n "$WC" && break
10780 done
10781
10782 else
10783 # If it succeeded, then it was overridden by the user. We will use it
10784 # for the tool.
10785
10786 # First remove it from the list of overridden variables, so we can test
10787 # for unknown variables in the end.
10788 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10789
10790 # Check if the provided tool contains a complete path.
10791 tool_specified="$WC"
10792 tool_basename="${tool_specified##*/}"
10793 if test "x$tool_basename" = "x$tool_specified"; then
10794 # A command without a complete path is provided, search $PATH.
10795 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10796 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10797 # Extract the first word of "$tool_basename", so it can be a program name with args.
10798 set dummy $tool_basename; ac_word=$2
10799 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10800 $as_echo_n "checking for $ac_word... " >&6; }
10801 if ${ac_cv_path_WC+:} false; then :
10802 $as_echo_n "(cached) " >&6
10803 else
10804 case $WC in
10805 [\\/]* | ?:[\\/]*)
10806 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10807 ;;
10808 *)
10809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10810 for as_dir in $PATH
10811 do
10812 IFS=$as_save_IFS
10813 test -z "$as_dir" && as_dir=.
10814 for ac_exec_ext in '' $ac_executable_extensions; do
10815 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10816 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10817 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10818 break 2
10819 fi
10820 done
10821 done
10822 IFS=$as_save_IFS
10823
10824 ;;
10825 esac
10826 fi
10827 WC=$ac_cv_path_WC
10828 if test -n "$WC"; then
10829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10830 $as_echo "$WC" >&6; }
10831 else
10832 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10833 $as_echo "no" >&6; }
10834 fi
10835
10836
10837 if test "x$WC" = x; then
10838 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10839 fi
10840 else
10841 # Otherwise we believe it is a complete path. Use it as it is.
10842 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10843 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10844 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10845 $as_echo_n "checking for WC... " >&6; }
10846 if test ! -x "$tool_specified"; then
10847 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10848 $as_echo "not found" >&6; }
10849 as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10850 fi
10851 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10852 $as_echo "$tool_specified" >&6; }
10853 fi
10854 fi
10855 fi
10856
10857
10858
10859 if test "x$WC" = x; then
10860 as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10861 fi
10862
10863
10864
10865
10866
10867 # Publish this variable in the help.
10868
10869
10870 if test "x$WHICH" = x; then
10871 # The variable is not set by user, try to locate tool using the code snippet
10872 for ac_prog in which
10873 do
10874 # Extract the first word of "$ac_prog", so it can be a program name with args.
10875 set dummy $ac_prog; ac_word=$2
10876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10877 $as_echo_n "checking for $ac_word... " >&6; }
10878 if ${ac_cv_path_WHICH+:} false; then :
10879 $as_echo_n "(cached) " >&6
10880 else
10881 case $WHICH in
10882 [\\/]* | ?:[\\/]*)
10883 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10884 ;;
10885 *)
10886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10887 for as_dir in $PATH
10888 do
10889 IFS=$as_save_IFS
10890 test -z "$as_dir" && as_dir=.
10891 for ac_exec_ext in '' $ac_executable_extensions; do
10892 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10893 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10894 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10895 break 2
10896 fi
10897 done
10898 done
10899 IFS=$as_save_IFS
10900
10901 ;;
10902 esac
10903 fi
10904 WHICH=$ac_cv_path_WHICH
10905 if test -n "$WHICH"; then
10906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
10907 $as_echo "$WHICH" >&6; }
10908 else
10909 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10910 $as_echo "no" >&6; }
10911 fi
10912
10913
10914 test -n "$WHICH" && break
10915 done
10916
10917 else
10918 # The variable is set, but is it from the command line or the environment?
10919
10920 # Try to remove the string !WHICH! from our list.
10921 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
10922 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10923 # If it failed, the variable was not from the command line. Ignore it,
10924 # but warn the user (except for BASH, which is always set by the calling BASH).
10925 if test "xWHICH" != xBASH; then
10926 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
10927 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
10928 fi
10929 # Try to locate tool using the code snippet
10930 for ac_prog in which
10931 do
10932 # Extract the first word of "$ac_prog", so it can be a program name with args.
10933 set dummy $ac_prog; ac_word=$2
10934 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10935 $as_echo_n "checking for $ac_word... " >&6; }
10936 if ${ac_cv_path_WHICH+:} false; then :
10937 $as_echo_n "(cached) " >&6
10938 else
10939 case $WHICH in
10940 [\\/]* | ?:[\\/]*)
10941 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10942 ;;
10943 *)
10944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10945 for as_dir in $PATH
10946 do
10947 IFS=$as_save_IFS
10948 test -z "$as_dir" && as_dir=.
10949 for ac_exec_ext in '' $ac_executable_extensions; do
10950 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10951 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10952 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10953 break 2
10954 fi
10955 done
10956 done
10957 IFS=$as_save_IFS
10958
10959 ;;
10960 esac
10961 fi
10962 WHICH=$ac_cv_path_WHICH
10963 if test -n "$WHICH"; then
10964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
10965 $as_echo "$WHICH" >&6; }
10966 else
10967 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10968 $as_echo "no" >&6; }
10969 fi
10970
10971
10972 test -n "$WHICH" && break
10973 done
10974
10975 else
10976 # If it succeeded, then it was overridden by the user. We will use it
10977 # for the tool.
10978
10979 # First remove it from the list of overridden variables, so we can test
10980 # for unknown variables in the end.
10981 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10982
10983 # Check if the provided tool contains a complete path.
10984 tool_specified="$WHICH"
10985 tool_basename="${tool_specified##*/}"
10986 if test "x$tool_basename" = "x$tool_specified"; then
10987 # A command without a complete path is provided, search $PATH.
10988 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
10989 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
10990 # Extract the first word of "$tool_basename", so it can be a program name with args.
10991 set dummy $tool_basename; ac_word=$2
10992 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10993 $as_echo_n "checking for $ac_word... " >&6; }
10994 if ${ac_cv_path_WHICH+:} false; then :
10995 $as_echo_n "(cached) " >&6
10996 else
10997 case $WHICH in
10998 [\\/]* | ?:[\\/]*)
10999 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11000 ;;
11001 *)
11002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11003 for as_dir in $PATH
11004 do
11005 IFS=$as_save_IFS
11006 test -z "$as_dir" && as_dir=.
11007 for ac_exec_ext in '' $ac_executable_extensions; do
11008 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11009 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11010 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11011 break 2
11012 fi
11013 done
11014 done
11015 IFS=$as_save_IFS
11016
11017 ;;
11018 esac
11019 fi
11020 WHICH=$ac_cv_path_WHICH
11021 if test -n "$WHICH"; then
11022 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11023 $as_echo "$WHICH" >&6; }
11024 else
11025 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11026 $as_echo "no" >&6; }
11027 fi
11028
11029
11030 if test "x$WHICH" = x; then
11031 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11032 fi
11033 else
11034 # Otherwise we believe it is a complete path. Use it as it is.
11035 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11036 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11037 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11038 $as_echo_n "checking for WHICH... " >&6; }
11039 if test ! -x "$tool_specified"; then
11040 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11041 $as_echo "not found" >&6; }
11042 as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11043 fi
11044 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11045 $as_echo "$tool_specified" >&6; }
11046 fi
11047 fi
11048 fi
11049
11050
11051
11052 if test "x$WHICH" = x; then
11053 as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11054 fi
11055
11056
11057
11058
11059
11060 # Publish this variable in the help.
11061
11062
11063 if test "x$XARGS" = x; then
11064 # The variable is not set by user, try to locate tool using the code snippet
11065 for ac_prog in xargs
11066 do
11067 # Extract the first word of "$ac_prog", so it can be a program name with args.
11068 set dummy $ac_prog; ac_word=$2
11069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11070 $as_echo_n "checking for $ac_word... " >&6; }
11071 if ${ac_cv_path_XARGS+:} false; then :
11072 $as_echo_n "(cached) " >&6
11073 else
11074 case $XARGS in
11075 [\\/]* | ?:[\\/]*)
11076 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11077 ;;
11078 *)
11079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11080 for as_dir in $PATH
11081 do
11082 IFS=$as_save_IFS
11083 test -z "$as_dir" && as_dir=.
11084 for ac_exec_ext in '' $ac_executable_extensions; do
11085 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11086 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11087 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11088 break 2
11089 fi
11090 done
11091 done
11092 IFS=$as_save_IFS
11093
11094 ;;
11095 esac
11096 fi
11097 XARGS=$ac_cv_path_XARGS
11098 if test -n "$XARGS"; then
11099 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11100 $as_echo "$XARGS" >&6; }
11101 else
11102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11103 $as_echo "no" >&6; }
11104 fi
11105
11106
11107 test -n "$XARGS" && break
11108 done
11109
11110 else
11111 # The variable is set, but is it from the command line or the environment?
11112
11113 # Try to remove the string !XARGS! from our list.
11114 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11115 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11116 # If it failed, the variable was not from the command line. Ignore it,
11117 # but warn the user (except for BASH, which is always set by the calling BASH).
11118 if test "xXARGS" != xBASH; then
11119 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11120 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11121 fi
11122 # Try to locate tool using the code snippet
11123 for ac_prog in xargs
11124 do
11125 # Extract the first word of "$ac_prog", so it can be a program name with args.
11126 set dummy $ac_prog; ac_word=$2
11127 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11128 $as_echo_n "checking for $ac_word... " >&6; }
11129 if ${ac_cv_path_XARGS+:} false; then :
11130 $as_echo_n "(cached) " >&6
11131 else
11132 case $XARGS in
11133 [\\/]* | ?:[\\/]*)
11134 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11135 ;;
11136 *)
11137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11138 for as_dir in $PATH
11139 do
11140 IFS=$as_save_IFS
11141 test -z "$as_dir" && as_dir=.
11142 for ac_exec_ext in '' $ac_executable_extensions; do
11143 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11144 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11145 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11146 break 2
11147 fi
11148 done
11149 done
11150 IFS=$as_save_IFS
11151
11152 ;;
11153 esac
11154 fi
11155 XARGS=$ac_cv_path_XARGS
11156 if test -n "$XARGS"; then
11157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11158 $as_echo "$XARGS" >&6; }
11159 else
11160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11161 $as_echo "no" >&6; }
11162 fi
11163
11164
11165 test -n "$XARGS" && break
11166 done
11167
11168 else
11169 # If it succeeded, then it was overridden by the user. We will use it
11170 # for the tool.
11171
11172 # First remove it from the list of overridden variables, so we can test
11173 # for unknown variables in the end.
11174 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11175
11176 # Check if the provided tool contains a complete path.
11177 tool_specified="$XARGS"
11178 tool_basename="${tool_specified##*/}"
11179 if test "x$tool_basename" = "x$tool_specified"; then
11180 # A command without a complete path is provided, search $PATH.
11181 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11182 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11183 # Extract the first word of "$tool_basename", so it can be a program name with args.
11184 set dummy $tool_basename; ac_word=$2
11185 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11186 $as_echo_n "checking for $ac_word... " >&6; }
11187 if ${ac_cv_path_XARGS+:} false; then :
11188 $as_echo_n "(cached) " >&6
11189 else
11190 case $XARGS in
11191 [\\/]* | ?:[\\/]*)
11192 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11193 ;;
11194 *)
11195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11196 for as_dir in $PATH
11197 do
11198 IFS=$as_save_IFS
11199 test -z "$as_dir" && as_dir=.
11200 for ac_exec_ext in '' $ac_executable_extensions; do
11201 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11202 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11203 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11204 break 2
11205 fi
11206 done
11207 done
11208 IFS=$as_save_IFS
11209
11210 ;;
11211 esac
11212 fi
11213 XARGS=$ac_cv_path_XARGS
11214 if test -n "$XARGS"; then
11215 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11216 $as_echo "$XARGS" >&6; }
11217 else
11218 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11219 $as_echo "no" >&6; }
11220 fi
11221
11222
11223 if test "x$XARGS" = x; then
11224 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11225 fi
11226 else
11227 # Otherwise we believe it is a complete path. Use it as it is.
11228 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11229 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11230 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11231 $as_echo_n "checking for XARGS... " >&6; }
11232 if test ! -x "$tool_specified"; then
11233 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11234 $as_echo "not found" >&6; }
11235 as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11236 fi
11237 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11238 $as_echo "$tool_specified" >&6; }
11239 fi
11240 fi
11241 fi
11242
11243
11244
11245 if test "x$XARGS" = x; then
11246 as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11247 fi
11248
11249
11250
11251 # Then required tools that require some special treatment.
11252
11253
11254 # Publish this variable in the help.
11255
11256
11257 if test "x$AWK" = x; then
11258 # The variable is not set by user, try to locate tool using the code snippet
11259 for ac_prog in gawk mawk nawk awk
11260 do
11261 # Extract the first word of "$ac_prog", so it can be a program name with args.
11262 set dummy $ac_prog; ac_word=$2
11263 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11264 $as_echo_n "checking for $ac_word... " >&6; }
11265 if ${ac_cv_prog_AWK+:} false; then :
11266 $as_echo_n "(cached) " >&6
11267 else
11268 if test -n "$AWK"; then
11269 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11270 else
11271 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11272 for as_dir in $PATH
11273 do
11274 IFS=$as_save_IFS
11275 test -z "$as_dir" && as_dir=.
11276 for ac_exec_ext in '' $ac_executable_extensions; do
11277 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11278 ac_cv_prog_AWK="$ac_prog"
11279 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11280 break 2
11281 fi
11282 done
11283 done
11284 IFS=$as_save_IFS
11285
11286 fi
11287 fi
11288 AWK=$ac_cv_prog_AWK
11289 if test -n "$AWK"; then
11290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11291 $as_echo "$AWK" >&6; }
11292 else
11293 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11294 $as_echo "no" >&6; }
11295 fi
11296
11297
11298 test -n "$AWK" && break
11299 done
11300
11301 else
11302 # The variable is set, but is it from the command line or the environment?
11303
11304 # Try to remove the string !AWK! from our list.
11305 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11306 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11307 # If it failed, the variable was not from the command line. Ignore it,
11308 # but warn the user (except for BASH, which is always set by the calling BASH).
11309 if test "xAWK" != xBASH; then
11310 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11311 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11312 fi
11313 # Try to locate tool using the code snippet
11314 for ac_prog in gawk mawk nawk awk
11315 do
11316 # Extract the first word of "$ac_prog", so it can be a program name with args.
11317 set dummy $ac_prog; ac_word=$2
11318 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11319 $as_echo_n "checking for $ac_word... " >&6; }
11320 if ${ac_cv_prog_AWK+:} false; then :
11321 $as_echo_n "(cached) " >&6
11322 else
11323 if test -n "$AWK"; then
11324 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11325 else
11326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11327 for as_dir in $PATH
11328 do
11329 IFS=$as_save_IFS
11330 test -z "$as_dir" && as_dir=.
11331 for ac_exec_ext in '' $ac_executable_extensions; do
11332 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11333 ac_cv_prog_AWK="$ac_prog"
11334 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11335 break 2
11336 fi
11337 done
11338 done
11339 IFS=$as_save_IFS
11340
11341 fi
11342 fi
11343 AWK=$ac_cv_prog_AWK
11344 if test -n "$AWK"; then
11345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11346 $as_echo "$AWK" >&6; }
11347 else
11348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11349 $as_echo "no" >&6; }
11350 fi
11351
11352
11353 test -n "$AWK" && break
11354 done
11355
11356 else
11357 # If it succeeded, then it was overridden by the user. We will use it
11358 # for the tool.
11359
11360 # First remove it from the list of overridden variables, so we can test
11361 # for unknown variables in the end.
11362 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11363
11364 # Check if the provided tool contains a complete path.
11365 tool_specified="$AWK"
11366 tool_basename="${tool_specified##*/}"
11367 if test "x$tool_basename" = "x$tool_specified"; then
11368 # A command without a complete path is provided, search $PATH.
11369 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11370 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11371 # Extract the first word of "$tool_basename", so it can be a program name with args.
11372 set dummy $tool_basename; ac_word=$2
11373 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11374 $as_echo_n "checking for $ac_word... " >&6; }
11375 if ${ac_cv_path_AWK+:} false; then :
11376 $as_echo_n "(cached) " >&6
11377 else
11378 case $AWK in
11379 [\\/]* | ?:[\\/]*)
11380 ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11381 ;;
11382 *)
11383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11384 for as_dir in $PATH
11385 do
11386 IFS=$as_save_IFS
11387 test -z "$as_dir" && as_dir=.
11388 for ac_exec_ext in '' $ac_executable_extensions; do
11389 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11390 ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11391 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11392 break 2
11393 fi
11394 done
11395 done
11396 IFS=$as_save_IFS
11397
11398 ;;
11399 esac
11400 fi
11401 AWK=$ac_cv_path_AWK
11402 if test -n "$AWK"; then
11403 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11404 $as_echo "$AWK" >&6; }
11405 else
11406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11407 $as_echo "no" >&6; }
11408 fi
11409
11410
11411 if test "x$AWK" = x; then
11412 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11413 fi
11414 else
11415 # Otherwise we believe it is a complete path. Use it as it is.
11416 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11417 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11419 $as_echo_n "checking for AWK... " >&6; }
11420 if test ! -x "$tool_specified"; then
11421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11422 $as_echo "not found" >&6; }
11423 as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11424 fi
11425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11426 $as_echo "$tool_specified" >&6; }
11427 fi
11428 fi
11429 fi
11430
11431
11432 if test "x$AWK" = x; then
11433 as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11434 fi
11435
11436
11437
11438
11439 # Publish this variable in the help.
11440
11441
11442 if test "x$GREP" = x; then
11443 # The variable is not set by user, try to locate tool using the code snippet
11444 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11445 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11446 if ${ac_cv_path_GREP+:} false; then :
11447 $as_echo_n "(cached) " >&6
11448 else
11449 if test -z "$GREP"; then
11450 ac_path_GREP_found=false
11451 # Loop through the user's path and test for each of PROGNAME-LIST
11452 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11453 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11454 do
11455 IFS=$as_save_IFS
11456 test -z "$as_dir" && as_dir=.
11457 for ac_prog in grep ggrep; do
11458 for ac_exec_ext in '' $ac_executable_extensions; do
11459 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11460 as_fn_executable_p "$ac_path_GREP" || continue
11461 # Check for GNU ac_path_GREP and select it if it is found.
11462 # Check for GNU $ac_path_GREP
11463 case `"$ac_path_GREP" --version 2>&1` in
11464 *GNU*)
11465 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11466 *)
11467 ac_count=0
11468 $as_echo_n 0123456789 >"conftest.in"
11469 while :
11470 do
11471 cat "conftest.in" "conftest.in" >"conftest.tmp"
11472 mv "conftest.tmp" "conftest.in"
11473 cp "conftest.in" "conftest.nl"
11474 $as_echo 'GREP' >> "conftest.nl"
11475 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11476 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11477 as_fn_arith $ac_count + 1 && ac_count=$as_val
11478 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11479 # Best one so far, save it but keep looking for a better one
11480 ac_cv_path_GREP="$ac_path_GREP"
11481 ac_path_GREP_max=$ac_count
11482 fi
11483 # 10*(2^10) chars as input seems more than enough
11484 test $ac_count -gt 10 && break
11485 done
11486 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11487 esac
11488
11489 $ac_path_GREP_found && break 3
11490 done
11491 done
11492 done
11493 IFS=$as_save_IFS
11494 if test -z "$ac_cv_path_GREP"; then
11495 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11496 fi
11497 else
11498 ac_cv_path_GREP=$GREP
11499 fi
11500
11501 fi
11502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11503 $as_echo "$ac_cv_path_GREP" >&6; }
11504 GREP="$ac_cv_path_GREP"
11505
11506
11507 else
11508 # The variable is set, but is it from the command line or the environment?
11509
11510 # Try to remove the string !GREP! from our list.
11511 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11512 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11513 # If it failed, the variable was not from the command line. Ignore it,
11514 # but warn the user (except for BASH, which is always set by the calling BASH).
11515 if test "xGREP" != xBASH; then
11516 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11517 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11518 fi
11519 # Try to locate tool using the code snippet
11520 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11521 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11522 if ${ac_cv_path_GREP+:} false; then :
11523 $as_echo_n "(cached) " >&6
11524 else
11525 if test -z "$GREP"; then
11526 ac_path_GREP_found=false
11527 # Loop through the user's path and test for each of PROGNAME-LIST
11528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11529 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11530 do
11531 IFS=$as_save_IFS
11532 test -z "$as_dir" && as_dir=.
11533 for ac_prog in grep ggrep; do
11534 for ac_exec_ext in '' $ac_executable_extensions; do
11535 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11536 as_fn_executable_p "$ac_path_GREP" || continue
11537 # Check for GNU ac_path_GREP and select it if it is found.
11538 # Check for GNU $ac_path_GREP
11539 case `"$ac_path_GREP" --version 2>&1` in
11540 *GNU*)
11541 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11542 *)
11543 ac_count=0
11544 $as_echo_n 0123456789 >"conftest.in"
11545 while :
11546 do
11547 cat "conftest.in" "conftest.in" >"conftest.tmp"
11548 mv "conftest.tmp" "conftest.in"
11549 cp "conftest.in" "conftest.nl"
11550 $as_echo 'GREP' >> "conftest.nl"
11551 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11552 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11553 as_fn_arith $ac_count + 1 && ac_count=$as_val
11554 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11555 # Best one so far, save it but keep looking for a better one
11556 ac_cv_path_GREP="$ac_path_GREP"
11557 ac_path_GREP_max=$ac_count
11558 fi
11559 # 10*(2^10) chars as input seems more than enough
11560 test $ac_count -gt 10 && break
11561 done
11562 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11563 esac
11564
11565 $ac_path_GREP_found && break 3
11566 done
11567 done
11568 done
11569 IFS=$as_save_IFS
11570 if test -z "$ac_cv_path_GREP"; then
11571 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11572 fi
11573 else
11574 ac_cv_path_GREP=$GREP
11575 fi
11576
11577 fi
11578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11579 $as_echo "$ac_cv_path_GREP" >&6; }
11580 GREP="$ac_cv_path_GREP"
11581
11582
11583 else
11584 # If it succeeded, then it was overridden by the user. We will use it
11585 # for the tool.
11586
11587 # First remove it from the list of overridden variables, so we can test
11588 # for unknown variables in the end.
11589 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11590
11591 # Check if the provided tool contains a complete path.
11592 tool_specified="$GREP"
11593 tool_basename="${tool_specified##*/}"
11594 if test "x$tool_basename" = "x$tool_specified"; then
11595 # A command without a complete path is provided, search $PATH.
11596 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11597 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11598 # Extract the first word of "$tool_basename", so it can be a program name with args.
11599 set dummy $tool_basename; ac_word=$2
11600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11601 $as_echo_n "checking for $ac_word... " >&6; }
11602 if ${ac_cv_path_GREP+:} false; then :
11603 $as_echo_n "(cached) " >&6
11604 else
11605 case $GREP in
11606 [\\/]* | ?:[\\/]*)
11607 ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11608 ;;
11609 *)
11610 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11611 for as_dir in $PATH
11612 do
11613 IFS=$as_save_IFS
11614 test -z "$as_dir" && as_dir=.
11615 for ac_exec_ext in '' $ac_executable_extensions; do
11616 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11617 ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11618 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11619 break 2
11620 fi
11621 done
11622 done
11623 IFS=$as_save_IFS
11624
11625 ;;
11626 esac
11627 fi
11628 GREP=$ac_cv_path_GREP
11629 if test -n "$GREP"; then
11630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11631 $as_echo "$GREP" >&6; }
11632 else
11633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11634 $as_echo "no" >&6; }
11635 fi
11636
11637
11638 if test "x$GREP" = x; then
11639 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11640 fi
11641 else
11642 # Otherwise we believe it is a complete path. Use it as it is.
11643 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11644 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11645 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11646 $as_echo_n "checking for GREP... " >&6; }
11647 if test ! -x "$tool_specified"; then
11648 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11649 $as_echo "not found" >&6; }
11650 as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11651 fi
11652 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11653 $as_echo "$tool_specified" >&6; }
11654 fi
11655 fi
11656 fi
11657
11658
11659 if test "x$GREP" = x; then
11660 as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11661 fi
11662
11663
11664
11665
11666 # Publish this variable in the help.
11667
11668
11669 if test "x$EGREP" = x; then
11670 # The variable is not set by user, try to locate tool using the code snippet
11671 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11672 $as_echo_n "checking for egrep... " >&6; }
11673 if ${ac_cv_path_EGREP+:} false; then :
11674 $as_echo_n "(cached) " >&6
11675 else
11676 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11677 then ac_cv_path_EGREP="$GREP -E"
11678 else
11679 if test -z "$EGREP"; then
11680 ac_path_EGREP_found=false
11681 # Loop through the user's path and test for each of PROGNAME-LIST
11682 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11683 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11684 do
11685 IFS=$as_save_IFS
11686 test -z "$as_dir" && as_dir=.
11687 for ac_prog in egrep; do
11688 for ac_exec_ext in '' $ac_executable_extensions; do
11689 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11690 as_fn_executable_p "$ac_path_EGREP" || continue
11691 # Check for GNU ac_path_EGREP and select it if it is found.
11692 # Check for GNU $ac_path_EGREP
11693 case `"$ac_path_EGREP" --version 2>&1` in
11694 *GNU*)
11695 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11696 *)
11697 ac_count=0
11698 $as_echo_n 0123456789 >"conftest.in"
11699 while :
11700 do
11701 cat "conftest.in" "conftest.in" >"conftest.tmp"
11702 mv "conftest.tmp" "conftest.in"
11703 cp "conftest.in" "conftest.nl"
11704 $as_echo 'EGREP' >> "conftest.nl"
11705 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11706 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11707 as_fn_arith $ac_count + 1 && ac_count=$as_val
11708 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11709 # Best one so far, save it but keep looking for a better one
11710 ac_cv_path_EGREP="$ac_path_EGREP"
11711 ac_path_EGREP_max=$ac_count
11712 fi
11713 # 10*(2^10) chars as input seems more than enough
11714 test $ac_count -gt 10 && break
11715 done
11716 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11717 esac
11718
11719 $ac_path_EGREP_found && break 3
11720 done
11721 done
11722 done
11723 IFS=$as_save_IFS
11724 if test -z "$ac_cv_path_EGREP"; then
11725 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11726 fi
11727 else
11728 ac_cv_path_EGREP=$EGREP
11729 fi
11730
11731 fi
11732 fi
11733 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11734 $as_echo "$ac_cv_path_EGREP" >&6; }
11735 EGREP="$ac_cv_path_EGREP"
11736
11737
11738 else
11739 # The variable is set, but is it from the command line or the environment?
11740
11741 # Try to remove the string !EGREP! from our list.
11742 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11743 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11744 # If it failed, the variable was not from the command line. Ignore it,
11745 # but warn the user (except for BASH, which is always set by the calling BASH).
11746 if test "xEGREP" != xBASH; then
11747 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11748 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11749 fi
11750 # Try to locate tool using the code snippet
11751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11752 $as_echo_n "checking for egrep... " >&6; }
11753 if ${ac_cv_path_EGREP+:} false; then :
11754 $as_echo_n "(cached) " >&6
11755 else
11756 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11757 then ac_cv_path_EGREP="$GREP -E"
11758 else
11759 if test -z "$EGREP"; then
11760 ac_path_EGREP_found=false
11761 # Loop through the user's path and test for each of PROGNAME-LIST
11762 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11763 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11764 do
11765 IFS=$as_save_IFS
11766 test -z "$as_dir" && as_dir=.
11767 for ac_prog in egrep; do
11768 for ac_exec_ext in '' $ac_executable_extensions; do
11769 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11770 as_fn_executable_p "$ac_path_EGREP" || continue
11771 # Check for GNU ac_path_EGREP and select it if it is found.
11772 # Check for GNU $ac_path_EGREP
11773 case `"$ac_path_EGREP" --version 2>&1` in
11774 *GNU*)
11775 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11776 *)
11777 ac_count=0
11778 $as_echo_n 0123456789 >"conftest.in"
11779 while :
11780 do
11781 cat "conftest.in" "conftest.in" >"conftest.tmp"
11782 mv "conftest.tmp" "conftest.in"
11783 cp "conftest.in" "conftest.nl"
11784 $as_echo 'EGREP' >> "conftest.nl"
11785 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11786 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11787 as_fn_arith $ac_count + 1 && ac_count=$as_val
11788 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11789 # Best one so far, save it but keep looking for a better one
11790 ac_cv_path_EGREP="$ac_path_EGREP"
11791 ac_path_EGREP_max=$ac_count
11792 fi
11793 # 10*(2^10) chars as input seems more than enough
11794 test $ac_count -gt 10 && break
11795 done
11796 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11797 esac
11798
11799 $ac_path_EGREP_found && break 3
11800 done
11801 done
11802 done
11803 IFS=$as_save_IFS
11804 if test -z "$ac_cv_path_EGREP"; then
11805 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11806 fi
11807 else
11808 ac_cv_path_EGREP=$EGREP
11809 fi
11810
11811 fi
11812 fi
11813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11814 $as_echo "$ac_cv_path_EGREP" >&6; }
11815 EGREP="$ac_cv_path_EGREP"
11816
11817
11818 else
11819 # If it succeeded, then it was overridden by the user. We will use it
11820 # for the tool.
11821
11822 # First remove it from the list of overridden variables, so we can test
11823 # for unknown variables in the end.
11824 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11825
11826 # Check if the provided tool contains a complete path.
11827 tool_specified="$EGREP"
11828 tool_basename="${tool_specified##*/}"
11829 if test "x$tool_basename" = "x$tool_specified"; then
11830 # A command without a complete path is provided, search $PATH.
11831 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11832 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11833 # Extract the first word of "$tool_basename", so it can be a program name with args.
11834 set dummy $tool_basename; ac_word=$2
11835 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11836 $as_echo_n "checking for $ac_word... " >&6; }
11837 if ${ac_cv_path_EGREP+:} false; then :
11838 $as_echo_n "(cached) " >&6
11839 else
11840 case $EGREP in
11841 [\\/]* | ?:[\\/]*)
11842 ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11843 ;;
11844 *)
11845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11846 for as_dir in $PATH
11847 do
11848 IFS=$as_save_IFS
11849 test -z "$as_dir" && as_dir=.
11850 for ac_exec_ext in '' $ac_executable_extensions; do
11851 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11852 ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11853 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11854 break 2
11855 fi
11856 done
11857 done
11858 IFS=$as_save_IFS
11859
11860 ;;
11861 esac
11862 fi
11863 EGREP=$ac_cv_path_EGREP
11864 if test -n "$EGREP"; then
11865 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11866 $as_echo "$EGREP" >&6; }
11867 else
11868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11869 $as_echo "no" >&6; }
11870 fi
11871
11872
11873 if test "x$EGREP" = x; then
11874 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11875 fi
11876 else
11877 # Otherwise we believe it is a complete path. Use it as it is.
11878 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
11879 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
11880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
11881 $as_echo_n "checking for EGREP... " >&6; }
11882 if test ! -x "$tool_specified"; then
11883 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11884 $as_echo "not found" >&6; }
11885 as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11886 fi
11887 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11888 $as_echo "$tool_specified" >&6; }
11889 fi
11890 fi
11891 fi
11892
11893
11894 if test "x$EGREP" = x; then
11895 as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
11896 fi
11897
11898
11899
11900
11901 # Publish this variable in the help.
11902
11903
11904 if test "x$FGREP" = x; then
11905 # The variable is not set by user, try to locate tool using the code snippet
11906 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
11907 $as_echo_n "checking for fgrep... " >&6; }
11908 if ${ac_cv_path_FGREP+:} false; then :
11909 $as_echo_n "(cached) " >&6
11910 else
11911 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
11912 then ac_cv_path_FGREP="$GREP -F"
11913 else
11914 if test -z "$FGREP"; then
11915 ac_path_FGREP_found=false
11916 # Loop through the user's path and test for each of PROGNAME-LIST
11917 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11918 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11919 do
11920 IFS=$as_save_IFS
11921 test -z "$as_dir" && as_dir=.
11922 for ac_prog in fgrep; do
11923 for ac_exec_ext in '' $ac_executable_extensions; do
11924 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
11925 as_fn_executable_p "$ac_path_FGREP" || continue
11926 # Check for GNU ac_path_FGREP and select it if it is found.
11927 # Check for GNU $ac_path_FGREP
11928 case `"$ac_path_FGREP" --version 2>&1` in
11929 *GNU*)
11930 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
11931 *)
11932 ac_count=0
11933 $as_echo_n 0123456789 >"conftest.in"
11934 while :
11935 do
11936 cat "conftest.in" "conftest.in" >"conftest.tmp"
11937 mv "conftest.tmp" "conftest.in"
11938 cp "conftest.in" "conftest.nl"
11939 $as_echo 'FGREP' >> "conftest.nl"
11940 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
11941 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11942 as_fn_arith $ac_count + 1 && ac_count=$as_val
11943 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
11944 # Best one so far, save it but keep looking for a better one
11945 ac_cv_path_FGREP="$ac_path_FGREP"
11946 ac_path_FGREP_max=$ac_count
11947 fi
11948 # 10*(2^10) chars as input seems more than enough
11949 test $ac_count -gt 10 && break
11950 done
11951 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11952 esac
11953
11954 $ac_path_FGREP_found && break 3
11955 done
11956 done
11957 done
11958 IFS=$as_save_IFS
11959 if test -z "$ac_cv_path_FGREP"; then
11960 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11961 fi
11962 else
11963 ac_cv_path_FGREP=$FGREP
11964 fi
11965
11966 fi
11967 fi
11968 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
11969 $as_echo "$ac_cv_path_FGREP" >&6; }
11970 FGREP="$ac_cv_path_FGREP"
11971
11972
11973 else
11974 # The variable is set, but is it from the command line or the environment?
11975
11976 # Try to remove the string !FGREP! from our list.
11977 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
11978 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11979 # If it failed, the variable was not from the command line. Ignore it,
11980 # but warn the user (except for BASH, which is always set by the calling BASH).
11981 if test "xFGREP" != xBASH; then
11982 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
11983 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
11984 fi
11985 # Try to locate tool using the code snippet
11986 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
11987 $as_echo_n "checking for fgrep... " >&6; }
11988 if ${ac_cv_path_FGREP+:} false; then :
11989 $as_echo_n "(cached) " >&6
11990 else
11991 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
11992 then ac_cv_path_FGREP="$GREP -F"
11993 else
11994 if test -z "$FGREP"; then
11995 ac_path_FGREP_found=false
11996 # Loop through the user's path and test for each of PROGNAME-LIST
11997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11998 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11999 do
12000 IFS=$as_save_IFS
12001 test -z "$as_dir" && as_dir=.
12002 for ac_prog in fgrep; do
12003 for ac_exec_ext in '' $ac_executable_extensions; do
12004 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12005 as_fn_executable_p "$ac_path_FGREP" || continue
12006 # Check for GNU ac_path_FGREP and select it if it is found.
12007 # Check for GNU $ac_path_FGREP
12008 case `"$ac_path_FGREP" --version 2>&1` in
12009 *GNU*)
12010 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12011 *)
12012 ac_count=0
12013 $as_echo_n 0123456789 >"conftest.in"
12014 while :
12015 do
12016 cat "conftest.in" "conftest.in" >"conftest.tmp"
12017 mv "conftest.tmp" "conftest.in"
12018 cp "conftest.in" "conftest.nl"
12019 $as_echo 'FGREP' >> "conftest.nl"
12020 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12021 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12022 as_fn_arith $ac_count + 1 && ac_count=$as_val
12023 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12024 # Best one so far, save it but keep looking for a better one
12025 ac_cv_path_FGREP="$ac_path_FGREP"
12026 ac_path_FGREP_max=$ac_count
12027 fi
12028 # 10*(2^10) chars as input seems more than enough
12029 test $ac_count -gt 10 && break
12030 done
12031 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12032 esac
12033
12034 $ac_path_FGREP_found && break 3
12035 done
12036 done
12037 done
12038 IFS=$as_save_IFS
12039 if test -z "$ac_cv_path_FGREP"; then
12040 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12041 fi
12042 else
12043 ac_cv_path_FGREP=$FGREP
12044 fi
12045
12046 fi
12047 fi
12048 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12049 $as_echo "$ac_cv_path_FGREP" >&6; }
12050 FGREP="$ac_cv_path_FGREP"
12051
12052
12053 else
12054 # If it succeeded, then it was overridden by the user. We will use it
12055 # for the tool.
12056
12057 # First remove it from the list of overridden variables, so we can test
12058 # for unknown variables in the end.
12059 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12060
12061 # Check if the provided tool contains a complete path.
12062 tool_specified="$FGREP"
12063 tool_basename="${tool_specified##*/}"
12064 if test "x$tool_basename" = "x$tool_specified"; then
12065 # A command without a complete path is provided, search $PATH.
12066 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12067 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12068 # Extract the first word of "$tool_basename", so it can be a program name with args.
12069 set dummy $tool_basename; ac_word=$2
12070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12071 $as_echo_n "checking for $ac_word... " >&6; }
12072 if ${ac_cv_path_FGREP+:} false; then :
12073 $as_echo_n "(cached) " >&6
12074 else
12075 case $FGREP in
12076 [\\/]* | ?:[\\/]*)
12077 ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12078 ;;
12079 *)
12080 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12081 for as_dir in $PATH
12082 do
12083 IFS=$as_save_IFS
12084 test -z "$as_dir" && as_dir=.
12085 for ac_exec_ext in '' $ac_executable_extensions; do
12086 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12087 ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12088 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12089 break 2
12090 fi
12091 done
12092 done
12093 IFS=$as_save_IFS
12094
12095 ;;
12096 esac
12097 fi
12098 FGREP=$ac_cv_path_FGREP
12099 if test -n "$FGREP"; then
12100 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12101 $as_echo "$FGREP" >&6; }
12102 else
12103 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12104 $as_echo "no" >&6; }
12105 fi
12106
12107
12108 if test "x$FGREP" = x; then
12109 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12110 fi
12111 else
12112 # Otherwise we believe it is a complete path. Use it as it is.
12113 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12114 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12116 $as_echo_n "checking for FGREP... " >&6; }
12117 if test ! -x "$tool_specified"; then
12118 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12119 $as_echo "not found" >&6; }
12120 as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12121 fi
12122 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12123 $as_echo "$tool_specified" >&6; }
12124 fi
12125 fi
12126 fi
12127
12128
12129 if test "x$FGREP" = x; then
12130 as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12131 fi
12132
12133
12134
12135
12136 # Publish this variable in the help.
12137
12138
12139 if test "x$SED" = x; then
12140 # The variable is not set by user, try to locate tool using the code snippet
12141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12142 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12143 if ${ac_cv_path_SED+:} false; then :
12144 $as_echo_n "(cached) " >&6
12145 else
12146 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12147 for ac_i in 1 2 3 4 5 6 7; do
12148 ac_script="$ac_script$as_nl$ac_script"
12149 done
12150 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12151 { ac_script=; unset ac_script;}
12152 if test -z "$SED"; then
12153 ac_path_SED_found=false
12154 # Loop through the user's path and test for each of PROGNAME-LIST
12155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12156 for as_dir in $PATH
12157 do
12158 IFS=$as_save_IFS
12159 test -z "$as_dir" && as_dir=.
12160 for ac_prog in sed gsed; do
12161 for ac_exec_ext in '' $ac_executable_extensions; do
12162 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12163 as_fn_executable_p "$ac_path_SED" || continue
12164 # Check for GNU ac_path_SED and select it if it is found.
12165 # Check for GNU $ac_path_SED
12166 case `"$ac_path_SED" --version 2>&1` in
12167 *GNU*)
12168 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12169 *)
12170 ac_count=0
12171 $as_echo_n 0123456789 >"conftest.in"
12172 while :
12173 do
12174 cat "conftest.in" "conftest.in" >"conftest.tmp"
12175 mv "conftest.tmp" "conftest.in"
12176 cp "conftest.in" "conftest.nl"
12177 $as_echo '' >> "conftest.nl"
12178 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12179 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12180 as_fn_arith $ac_count + 1 && ac_count=$as_val
12181 if test $ac_count -gt ${ac_path_SED_max-0}; then
12182 # Best one so far, save it but keep looking for a better one
12183 ac_cv_path_SED="$ac_path_SED"
12184 ac_path_SED_max=$ac_count
12185 fi
12186 # 10*(2^10) chars as input seems more than enough
12187 test $ac_count -gt 10 && break
12188 done
12189 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12190 esac
12191
12192 $ac_path_SED_found && break 3
12193 done
12194 done
12195 done
12196 IFS=$as_save_IFS
12197 if test -z "$ac_cv_path_SED"; then
12198 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12199 fi
12200 else
12201 ac_cv_path_SED=$SED
12202 fi
12203
12204 fi
12205 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12206 $as_echo "$ac_cv_path_SED" >&6; }
12207 SED="$ac_cv_path_SED"
12208 rm -f conftest.sed
12209
12210 else
12211 # The variable is set, but is it from the command line or the environment?
12212
12213 # Try to remove the string !SED! from our list.
12214 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12215 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12216 # If it failed, the variable was not from the command line. Ignore it,
12217 # but warn the user (except for BASH, which is always set by the calling BASH).
12218 if test "xSED" != xBASH; then
12219 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12220 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12221 fi
12222 # Try to locate tool using the code snippet
12223 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12224 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12225 if ${ac_cv_path_SED+:} false; then :
12226 $as_echo_n "(cached) " >&6
12227 else
12228 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12229 for ac_i in 1 2 3 4 5 6 7; do
12230 ac_script="$ac_script$as_nl$ac_script"
12231 done
12232 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12233 { ac_script=; unset ac_script;}
12234 if test -z "$SED"; then
12235 ac_path_SED_found=false
12236 # Loop through the user's path and test for each of PROGNAME-LIST
12237 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12238 for as_dir in $PATH
12239 do
12240 IFS=$as_save_IFS
12241 test -z "$as_dir" && as_dir=.
12242 for ac_prog in sed gsed; do
12243 for ac_exec_ext in '' $ac_executable_extensions; do
12244 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12245 as_fn_executable_p "$ac_path_SED" || continue
12246 # Check for GNU ac_path_SED and select it if it is found.
12247 # Check for GNU $ac_path_SED
12248 case `"$ac_path_SED" --version 2>&1` in
12249 *GNU*)
12250 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12251 *)
12252 ac_count=0
12253 $as_echo_n 0123456789 >"conftest.in"
12254 while :
12255 do
12256 cat "conftest.in" "conftest.in" >"conftest.tmp"
12257 mv "conftest.tmp" "conftest.in"
12258 cp "conftest.in" "conftest.nl"
12259 $as_echo '' >> "conftest.nl"
12260 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12261 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12262 as_fn_arith $ac_count + 1 && ac_count=$as_val
12263 if test $ac_count -gt ${ac_path_SED_max-0}; then
12264 # Best one so far, save it but keep looking for a better one
12265 ac_cv_path_SED="$ac_path_SED"
12266 ac_path_SED_max=$ac_count
12267 fi
12268 # 10*(2^10) chars as input seems more than enough
12269 test $ac_count -gt 10 && break
12270 done
12271 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12272 esac
12273
12274 $ac_path_SED_found && break 3
12275 done
12276 done
12277 done
12278 IFS=$as_save_IFS
12279 if test -z "$ac_cv_path_SED"; then
12280 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12281 fi
12282 else
12283 ac_cv_path_SED=$SED
12284 fi
12285
12286 fi
12287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12288 $as_echo "$ac_cv_path_SED" >&6; }
12289 SED="$ac_cv_path_SED"
12290 rm -f conftest.sed
12291
12292 else
12293 # If it succeeded, then it was overridden by the user. We will use it
12294 # for the tool.
12295
12296 # First remove it from the list of overridden variables, so we can test
12297 # for unknown variables in the end.
12298 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12299
12300 # Check if the provided tool contains a complete path.
12301 tool_specified="$SED"
12302 tool_basename="${tool_specified##*/}"
12303 if test "x$tool_basename" = "x$tool_specified"; then
12304 # A command without a complete path is provided, search $PATH.
12305 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12306 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12307 # Extract the first word of "$tool_basename", so it can be a program name with args.
12308 set dummy $tool_basename; ac_word=$2
12309 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12310 $as_echo_n "checking for $ac_word... " >&6; }
12311 if ${ac_cv_path_SED+:} false; then :
12312 $as_echo_n "(cached) " >&6
12313 else
12314 case $SED in
12315 [\\/]* | ?:[\\/]*)
12316 ac_cv_path_SED="$SED" # Let the user override the test with a path.
12317 ;;
12318 *)
12319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12320 for as_dir in $PATH
12321 do
12322 IFS=$as_save_IFS
12323 test -z "$as_dir" && as_dir=.
12324 for ac_exec_ext in '' $ac_executable_extensions; do
12325 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12326 ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12327 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12328 break 2
12329 fi
12330 done
12331 done
12332 IFS=$as_save_IFS
12333
12334 ;;
12335 esac
12336 fi
12337 SED=$ac_cv_path_SED
12338 if test -n "$SED"; then
12339 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12340 $as_echo "$SED" >&6; }
12341 else
12342 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12343 $as_echo "no" >&6; }
12344 fi
12345
12346
12347 if test "x$SED" = x; then
12348 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12349 fi
12350 else
12351 # Otherwise we believe it is a complete path. Use it as it is.
12352 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12353 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12355 $as_echo_n "checking for SED... " >&6; }
12356 if test ! -x "$tool_specified"; then
12357 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12358 $as_echo "not found" >&6; }
12359 as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12360 fi
12361 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12362 $as_echo "$tool_specified" >&6; }
12363 fi
12364 fi
12365 fi
12366
12367
12368 if test "x$SED" = x; then
12369 as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12370 fi
12371
12372
12373
12374 # Always force rm.
12375 RM="$RM -f"
12376
12377 # pwd behaves differently on various platforms and some don't support the -L flag.
12378 # Always use the bash builtin pwd to get uniform behavior.
12379 THEPWDCMD=pwd
12380
12381 # These are not required on all platforms
12382
12383
12384 # Publish this variable in the help.
12385
12386
12387 if test "x$CYGPATH" = x; then
12388 # The variable is not set by user, try to locate tool using the code snippet
12389 for ac_prog in cygpath
12390 do
12391 # Extract the first word of "$ac_prog", so it can be a program name with args.
12392 set dummy $ac_prog; ac_word=$2
12393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12394 $as_echo_n "checking for $ac_word... " >&6; }
12395 if ${ac_cv_path_CYGPATH+:} false; then :
12396 $as_echo_n "(cached) " >&6
12397 else
12398 case $CYGPATH in
12399 [\\/]* | ?:[\\/]*)
12400 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12401 ;;
12402 *)
12403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12404 for as_dir in $PATH
12405 do
12406 IFS=$as_save_IFS
12407 test -z "$as_dir" && as_dir=.
12408 for ac_exec_ext in '' $ac_executable_extensions; do
12409 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12410 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12411 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12412 break 2
12413 fi
12414 done
12415 done
12416 IFS=$as_save_IFS
12417
12418 ;;
12419 esac
12420 fi
12421 CYGPATH=$ac_cv_path_CYGPATH
12422 if test -n "$CYGPATH"; then
12423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12424 $as_echo "$CYGPATH" >&6; }
12425 else
12426 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12427 $as_echo "no" >&6; }
12428 fi
12429
12430
12431 test -n "$CYGPATH" && break
12432 done
12433
12434 else
12435 # The variable is set, but is it from the command line or the environment?
12436
12437 # Try to remove the string !CYGPATH! from our list.
12438 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12439 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12440 # If it failed, the variable was not from the command line. Ignore it,
12441 # but warn the user (except for BASH, which is always set by the calling BASH).
12442 if test "xCYGPATH" != xBASH; then
12443 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12444 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12445 fi
12446 # Try to locate tool using the code snippet
12447 for ac_prog in cygpath
12448 do
12449 # Extract the first word of "$ac_prog", so it can be a program name with args.
12450 set dummy $ac_prog; ac_word=$2
12451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12452 $as_echo_n "checking for $ac_word... " >&6; }
12453 if ${ac_cv_path_CYGPATH+:} false; then :
12454 $as_echo_n "(cached) " >&6
12455 else
12456 case $CYGPATH in
12457 [\\/]* | ?:[\\/]*)
12458 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12459 ;;
12460 *)
12461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12462 for as_dir in $PATH
12463 do
12464 IFS=$as_save_IFS
12465 test -z "$as_dir" && as_dir=.
12466 for ac_exec_ext in '' $ac_executable_extensions; do
12467 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12468 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12469 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12470 break 2
12471 fi
12472 done
12473 done
12474 IFS=$as_save_IFS
12475
12476 ;;
12477 esac
12478 fi
12479 CYGPATH=$ac_cv_path_CYGPATH
12480 if test -n "$CYGPATH"; then
12481 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12482 $as_echo "$CYGPATH" >&6; }
12483 else
12484 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12485 $as_echo "no" >&6; }
12486 fi
12487
12488
12489 test -n "$CYGPATH" && break
12490 done
12491
12492 else
12493 # If it succeeded, then it was overridden by the user. We will use it
12494 # for the tool.
12495
12496 # First remove it from the list of overridden variables, so we can test
12497 # for unknown variables in the end.
12498 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12499
12500 # Check if the provided tool contains a complete path.
12501 tool_specified="$CYGPATH"
12502 tool_basename="${tool_specified##*/}"
12503 if test "x$tool_basename" = "x$tool_specified"; then
12504 # A command without a complete path is provided, search $PATH.
12505 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12506 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12507 # Extract the first word of "$tool_basename", so it can be a program name with args.
12508 set dummy $tool_basename; ac_word=$2
12509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12510 $as_echo_n "checking for $ac_word... " >&6; }
12511 if ${ac_cv_path_CYGPATH+:} false; then :
12512 $as_echo_n "(cached) " >&6
12513 else
12514 case $CYGPATH in
12515 [\\/]* | ?:[\\/]*)
12516 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12517 ;;
12518 *)
12519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12520 for as_dir in $PATH
12521 do
12522 IFS=$as_save_IFS
12523 test -z "$as_dir" && as_dir=.
12524 for ac_exec_ext in '' $ac_executable_extensions; do
12525 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12526 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12527 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12528 break 2
12529 fi
12530 done
12531 done
12532 IFS=$as_save_IFS
12533
12534 ;;
12535 esac
12536 fi
12537 CYGPATH=$ac_cv_path_CYGPATH
12538 if test -n "$CYGPATH"; then
12539 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12540 $as_echo "$CYGPATH" >&6; }
12541 else
12542 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12543 $as_echo "no" >&6; }
12544 fi
12545
12546
12547 if test "x$CYGPATH" = x; then
12548 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12549 fi
12550 else
12551 # Otherwise we believe it is a complete path. Use it as it is.
12552 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12553 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12554 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12555 $as_echo_n "checking for CYGPATH... " >&6; }
12556 if test ! -x "$tool_specified"; then
12557 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12558 $as_echo "not found" >&6; }
12559 as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12560 fi
12561 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12562 $as_echo "$tool_specified" >&6; }
12563 fi
12564 fi
12565 fi
12566
12567
12568
12569
12570 # Publish this variable in the help.
12571
12572
12573 if test "x$READLINK" = x; then
12574 # The variable is not set by user, try to locate tool using the code snippet
12575 for ac_prog in greadlink readlink
12576 do
12577 # Extract the first word of "$ac_prog", so it can be a program name with args.
12578 set dummy $ac_prog; ac_word=$2
12579 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12580 $as_echo_n "checking for $ac_word... " >&6; }
12581 if ${ac_cv_path_READLINK+:} false; then :
12582 $as_echo_n "(cached) " >&6
12583 else
12584 case $READLINK in
12585 [\\/]* | ?:[\\/]*)
12586 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12587 ;;
12588 *)
12589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12590 for as_dir in $PATH
12591 do
12592 IFS=$as_save_IFS
12593 test -z "$as_dir" && as_dir=.
12594 for ac_exec_ext in '' $ac_executable_extensions; do
12595 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12596 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12597 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12598 break 2
12599 fi
12600 done
12601 done
12602 IFS=$as_save_IFS
12603
12604 ;;
12605 esac
12606 fi
12607 READLINK=$ac_cv_path_READLINK
12608 if test -n "$READLINK"; then
12609 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12610 $as_echo "$READLINK" >&6; }
12611 else
12612 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12613 $as_echo "no" >&6; }
12614 fi
12615
12616
12617 test -n "$READLINK" && break
12618 done
12619
12620 else
12621 # The variable is set, but is it from the command line or the environment?
12622
12623 # Try to remove the string !READLINK! from our list.
12624 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12625 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12626 # If it failed, the variable was not from the command line. Ignore it,
12627 # but warn the user (except for BASH, which is always set by the calling BASH).
12628 if test "xREADLINK" != xBASH; then
12629 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12630 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12631 fi
12632 # Try to locate tool using the code snippet
12633 for ac_prog in greadlink readlink
12634 do
12635 # Extract the first word of "$ac_prog", so it can be a program name with args.
12636 set dummy $ac_prog; ac_word=$2
12637 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12638 $as_echo_n "checking for $ac_word... " >&6; }
12639 if ${ac_cv_path_READLINK+:} false; then :
12640 $as_echo_n "(cached) " >&6
12641 else
12642 case $READLINK in
12643 [\\/]* | ?:[\\/]*)
12644 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12645 ;;
12646 *)
12647 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12648 for as_dir in $PATH
12649 do
12650 IFS=$as_save_IFS
12651 test -z "$as_dir" && as_dir=.
12652 for ac_exec_ext in '' $ac_executable_extensions; do
12653 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12654 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12655 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12656 break 2
12657 fi
12658 done
12659 done
12660 IFS=$as_save_IFS
12661
12662 ;;
12663 esac
12664 fi
12665 READLINK=$ac_cv_path_READLINK
12666 if test -n "$READLINK"; then
12667 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12668 $as_echo "$READLINK" >&6; }
12669 else
12670 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12671 $as_echo "no" >&6; }
12672 fi
12673
12674
12675 test -n "$READLINK" && break
12676 done
12677
12678 else
12679 # If it succeeded, then it was overridden by the user. We will use it
12680 # for the tool.
12681
12682 # First remove it from the list of overridden variables, so we can test
12683 # for unknown variables in the end.
12684 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12685
12686 # Check if the provided tool contains a complete path.
12687 tool_specified="$READLINK"
12688 tool_basename="${tool_specified##*/}"
12689 if test "x$tool_basename" = "x$tool_specified"; then
12690 # A command without a complete path is provided, search $PATH.
12691 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12692 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12693 # Extract the first word of "$tool_basename", so it can be a program name with args.
12694 set dummy $tool_basename; ac_word=$2
12695 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12696 $as_echo_n "checking for $ac_word... " >&6; }
12697 if ${ac_cv_path_READLINK+:} false; then :
12698 $as_echo_n "(cached) " >&6
12699 else
12700 case $READLINK in
12701 [\\/]* | ?:[\\/]*)
12702 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12703 ;;
12704 *)
12705 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12706 for as_dir in $PATH
12707 do
12708 IFS=$as_save_IFS
12709 test -z "$as_dir" && as_dir=.
12710 for ac_exec_ext in '' $ac_executable_extensions; do
12711 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12712 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12713 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12714 break 2
12715 fi
12716 done
12717 done
12718 IFS=$as_save_IFS
12719
12720 ;;
12721 esac
12722 fi
12723 READLINK=$ac_cv_path_READLINK
12724 if test -n "$READLINK"; then
12725 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12726 $as_echo "$READLINK" >&6; }
12727 else
12728 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12729 $as_echo "no" >&6; }
12730 fi
12731
12732
12733 if test "x$READLINK" = x; then
12734 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12735 fi
12736 else
12737 # Otherwise we believe it is a complete path. Use it as it is.
12738 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12739 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12740 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12741 $as_echo_n "checking for READLINK... " >&6; }
12742 if test ! -x "$tool_specified"; then
12743 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12744 $as_echo "not found" >&6; }
12745 as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12746 fi
12747 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12748 $as_echo "$tool_specified" >&6; }
12749 fi
12750 fi
12751 fi
12752
12753
12754
12755
12756 # Publish this variable in the help.
12757
12758
12759 if test "x$DF" = x; then
12760 # The variable is not set by user, try to locate tool using the code snippet
12761 for ac_prog in df
12762 do
12763 # Extract the first word of "$ac_prog", so it can be a program name with args.
12764 set dummy $ac_prog; ac_word=$2
12765 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12766 $as_echo_n "checking for $ac_word... " >&6; }
12767 if ${ac_cv_path_DF+:} false; then :
12768 $as_echo_n "(cached) " >&6
12769 else
12770 case $DF in
12771 [\\/]* | ?:[\\/]*)
12772 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12773 ;;
12774 *)
12775 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12776 for as_dir in $PATH
12777 do
12778 IFS=$as_save_IFS
12779 test -z "$as_dir" && as_dir=.
12780 for ac_exec_ext in '' $ac_executable_extensions; do
12781 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12782 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12783 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12784 break 2
12785 fi
12786 done
12787 done
12788 IFS=$as_save_IFS
12789
12790 ;;
12791 esac
12792 fi
12793 DF=$ac_cv_path_DF
12794 if test -n "$DF"; then
12795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12796 $as_echo "$DF" >&6; }
12797 else
12798 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12799 $as_echo "no" >&6; }
12800 fi
12801
12802
12803 test -n "$DF" && break
12804 done
12805
12806 else
12807 # The variable is set, but is it from the command line or the environment?
12808
12809 # Try to remove the string !DF! from our list.
12810 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12811 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12812 # If it failed, the variable was not from the command line. Ignore it,
12813 # but warn the user (except for BASH, which is always set by the calling BASH).
12814 if test "xDF" != xBASH; then
12815 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12816 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12817 fi
12818 # Try to locate tool using the code snippet
12819 for ac_prog in df
12820 do
12821 # Extract the first word of "$ac_prog", so it can be a program name with args.
12822 set dummy $ac_prog; ac_word=$2
12823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12824 $as_echo_n "checking for $ac_word... " >&6; }
12825 if ${ac_cv_path_DF+:} false; then :
12826 $as_echo_n "(cached) " >&6
12827 else
12828 case $DF in
12829 [\\/]* | ?:[\\/]*)
12830 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12831 ;;
12832 *)
12833 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12834 for as_dir in $PATH
12835 do
12836 IFS=$as_save_IFS
12837 test -z "$as_dir" && as_dir=.
12838 for ac_exec_ext in '' $ac_executable_extensions; do
12839 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12840 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12841 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12842 break 2
12843 fi
12844 done
12845 done
12846 IFS=$as_save_IFS
12847
12848 ;;
12849 esac
12850 fi
12851 DF=$ac_cv_path_DF
12852 if test -n "$DF"; then
12853 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12854 $as_echo "$DF" >&6; }
12855 else
12856 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12857 $as_echo "no" >&6; }
12858 fi
12859
12860
12861 test -n "$DF" && break
12862 done
12863
12864 else
12865 # If it succeeded, then it was overridden by the user. We will use it
12866 # for the tool.
12867
12868 # First remove it from the list of overridden variables, so we can test
12869 # for unknown variables in the end.
12870 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12871
12872 # Check if the provided tool contains a complete path.
12873 tool_specified="$DF"
12874 tool_basename="${tool_specified##*/}"
12875 if test "x$tool_basename" = "x$tool_specified"; then
12876 # A command without a complete path is provided, search $PATH.
12877 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
12878 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
12879 # Extract the first word of "$tool_basename", so it can be a program name with args.
12880 set dummy $tool_basename; ac_word=$2
12881 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12882 $as_echo_n "checking for $ac_word... " >&6; }
12883 if ${ac_cv_path_DF+:} false; then :
12884 $as_echo_n "(cached) " >&6
12885 else
12886 case $DF in
12887 [\\/]* | ?:[\\/]*)
12888 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12889 ;;
12890 *)
12891 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12892 for as_dir in $PATH
12893 do
12894 IFS=$as_save_IFS
12895 test -z "$as_dir" && as_dir=.
12896 for ac_exec_ext in '' $ac_executable_extensions; do
12897 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12898 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12899 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12900 break 2
12901 fi
12902 done
12903 done
12904 IFS=$as_save_IFS
12905
12906 ;;
12907 esac
12908 fi
12909 DF=$ac_cv_path_DF
12910 if test -n "$DF"; then
12911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12912 $as_echo "$DF" >&6; }
12913 else
12914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12915 $as_echo "no" >&6; }
12916 fi
12917
12918
12919 if test "x$DF" = x; then
12920 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12921 fi
12922 else
12923 # Otherwise we believe it is a complete path. Use it as it is.
12924 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
12925 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
12926 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
12927 $as_echo_n "checking for DF... " >&6; }
12928 if test ! -x "$tool_specified"; then
12929 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12930 $as_echo "not found" >&6; }
12931 as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
12932 fi
12933 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12934 $as_echo "$tool_specified" >&6; }
12935 fi
12936 fi
12937 fi
12938
12939
12940
12941
12942 # Publish this variable in the help.
12943
12944
12945 if test "x$SETFILE" = x; then
12946 # The variable is not set by user, try to locate tool using the code snippet
12947 for ac_prog in SetFile
12948 do
12949 # Extract the first word of "$ac_prog", so it can be a program name with args.
12950 set dummy $ac_prog; ac_word=$2
12951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12952 $as_echo_n "checking for $ac_word... " >&6; }
12953 if ${ac_cv_path_SETFILE+:} false; then :
12954 $as_echo_n "(cached) " >&6
12955 else
12956 case $SETFILE in
12957 [\\/]* | ?:[\\/]*)
12958 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
12959 ;;
12960 *)
12961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12962 for as_dir in $PATH
12963 do
12964 IFS=$as_save_IFS
12965 test -z "$as_dir" && as_dir=.
12966 for ac_exec_ext in '' $ac_executable_extensions; do
12967 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12968 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
12969 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12970 break 2
12971 fi
12972 done
12973 done
12974 IFS=$as_save_IFS
12975
12976 ;;
12977 esac
12978 fi
12979 SETFILE=$ac_cv_path_SETFILE
12980 if test -n "$SETFILE"; then
12981 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
12982 $as_echo "$SETFILE" >&6; }
12983 else
12984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12985 $as_echo "no" >&6; }
12986 fi
12987
12988
12989 test -n "$SETFILE" && break
12990 done
12991
12992 else
12993 # The variable is set, but is it from the command line or the environment?
12994
12995 # Try to remove the string !SETFILE! from our list.
12996 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
12997 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12998 # If it failed, the variable was not from the command line. Ignore it,
12999 # but warn the user (except for BASH, which is always set by the calling BASH).
13000 if test "xSETFILE" != xBASH; then
13001 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13002 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13003 fi
13004 # Try to locate tool using the code snippet
13005 for ac_prog in SetFile
13006 do
13007 # Extract the first word of "$ac_prog", so it can be a program name with args.
13008 set dummy $ac_prog; ac_word=$2
13009 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13010 $as_echo_n "checking for $ac_word... " >&6; }
13011 if ${ac_cv_path_SETFILE+:} false; then :
13012 $as_echo_n "(cached) " >&6
13013 else
13014 case $SETFILE in
13015 [\\/]* | ?:[\\/]*)
13016 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13017 ;;
13018 *)
13019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13020 for as_dir in $PATH
13021 do
13022 IFS=$as_save_IFS
13023 test -z "$as_dir" && as_dir=.
13024 for ac_exec_ext in '' $ac_executable_extensions; do
13025 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13026 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13027 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13028 break 2
13029 fi
13030 done
13031 done
13032 IFS=$as_save_IFS
13033
13034 ;;
13035 esac
13036 fi
13037 SETFILE=$ac_cv_path_SETFILE
13038 if test -n "$SETFILE"; then
13039 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13040 $as_echo "$SETFILE" >&6; }
13041 else
13042 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13043 $as_echo "no" >&6; }
13044 fi
13045
13046
13047 test -n "$SETFILE" && break
13048 done
13049
13050 else
13051 # If it succeeded, then it was overridden by the user. We will use it
13052 # for the tool.
13053
13054 # First remove it from the list of overridden variables, so we can test
13055 # for unknown variables in the end.
13056 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13057
13058 # Check if the provided tool contains a complete path.
13059 tool_specified="$SETFILE"
13060 tool_basename="${tool_specified##*/}"
13061 if test "x$tool_basename" = "x$tool_specified"; then
13062 # A command without a complete path is provided, search $PATH.
13063 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13064 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13065 # Extract the first word of "$tool_basename", so it can be a program name with args.
13066 set dummy $tool_basename; ac_word=$2
13067 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13068 $as_echo_n "checking for $ac_word... " >&6; }
13069 if ${ac_cv_path_SETFILE+:} false; then :
13070 $as_echo_n "(cached) " >&6
13071 else
13072 case $SETFILE in
13073 [\\/]* | ?:[\\/]*)
13074 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13075 ;;
13076 *)
13077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13078 for as_dir in $PATH
13079 do
13080 IFS=$as_save_IFS
13081 test -z "$as_dir" && as_dir=.
13082 for ac_exec_ext in '' $ac_executable_extensions; do
13083 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13084 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13085 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13086 break 2
13087 fi
13088 done
13089 done
13090 IFS=$as_save_IFS
13091
13092 ;;
13093 esac
13094 fi
13095 SETFILE=$ac_cv_path_SETFILE
13096 if test -n "$SETFILE"; then
13097 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13098 $as_echo "$SETFILE" >&6; }
13099 else
13100 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13101 $as_echo "no" >&6; }
13102 fi
13103
13104
13105 if test "x$SETFILE" = x; then
13106 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13107 fi
13108 else
13109 # Otherwise we believe it is a complete path. Use it as it is.
13110 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13111 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13112 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13113 $as_echo_n "checking for SETFILE... " >&6; }
13114 if test ! -x "$tool_specified"; then
13115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13116 $as_echo "not found" >&6; }
13117 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13118 fi
13119 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13120 $as_echo "$tool_specified" >&6; }
13121 fi
13122 fi
13123 fi
13124
13125
13126
13127
13128 # Now we can determine OpenJDK build and target platforms. This is required to
13129 # have early on.
13130 # Make sure we can run config.sub.
13131 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13132 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13133
13134 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13135 $as_echo_n "checking build system type... " >&6; }
13136 if ${ac_cv_build+:} false; then :
13137 $as_echo_n "(cached) " >&6
13138 else
13139 ac_build_alias=$build_alias
13140 test "x$ac_build_alias" = x &&
13141 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13142 test "x$ac_build_alias" = x &&
13143 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13144 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13145 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13146
13147 fi
13148 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13149 $as_echo "$ac_cv_build" >&6; }
13150 case $ac_cv_build in
13151 *-*-*) ;;
13152 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13153 esac
13154 build=$ac_cv_build
13155 ac_save_IFS=$IFS; IFS='-'
13156 set x $ac_cv_build
13157 shift
13158 build_cpu=$1
13159 build_vendor=$2
13160 shift; shift
13161 # Remember, the first character of IFS is used to create $*,
13162 # except with old shells:
13163 build_os=$*
13164 IFS=$ac_save_IFS
13165 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13166
13167
13168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13169 $as_echo_n "checking host system type... " >&6; }
13170 if ${ac_cv_host+:} false; then :
13171 $as_echo_n "(cached) " >&6
13172 else
13173 if test "x$host_alias" = x; then
13174 ac_cv_host=$ac_cv_build
13175 else
13176 ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13177 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13178 fi
13179
13180 fi
13181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13182 $as_echo "$ac_cv_host" >&6; }
13183 case $ac_cv_host in
13184 *-*-*) ;;
13185 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13186 esac
13187 host=$ac_cv_host
13188 ac_save_IFS=$IFS; IFS='-'
13189 set x $ac_cv_host
13190 shift
13191 host_cpu=$1
13192 host_vendor=$2
13193 shift; shift
13194 # Remember, the first character of IFS is used to create $*,
13195 # except with old shells:
13196 host_os=$*
13197 IFS=$ac_save_IFS
13198 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13199
13200
13201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13202 $as_echo_n "checking target system type... " >&6; }
13203 if ${ac_cv_target+:} false; then :
13204 $as_echo_n "(cached) " >&6
13205 else
13206 if test "x$target_alias" = x; then
13207 ac_cv_target=$ac_cv_host
13208 else
13209 ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13210 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13211 fi
13212
13213 fi
13214 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13215 $as_echo "$ac_cv_target" >&6; }
13216 case $ac_cv_target in
13217 *-*-*) ;;
13218 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13219 esac
13220 target=$ac_cv_target
13221 ac_save_IFS=$IFS; IFS='-'
13222 set x $ac_cv_target
13223 shift
13224 target_cpu=$1
13225 target_vendor=$2
13226 shift; shift
13227 # Remember, the first character of IFS is used to create $*,
13228 # except with old shells:
13229 target_os=$*
13230 IFS=$ac_save_IFS
13231 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13232
13233
13234 # The aliases save the names the user supplied, while $host etc.
13235 # will get canonicalized.
13236 test -n "$target_alias" &&
13237 test "$program_prefix$program_suffix$program_transform_name" = \
13238 NONENONEs,x,x, &&
13239 program_prefix=${target_alias}-
13240
13241 # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13242 # is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
13243 # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13244 # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13245 # to use the configure naming style.
13246
13247
13248
13249
13250
13251 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13252 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13253 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13254 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13255 OPENJDK_TARGET_AUTOCONF_NAME="$host"
13256 OPENJDK_BUILD_AUTOCONF_NAME="$build"
13257
13258
13259
13260 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13261
13262 case "$build_os" in
13263 *linux*)
13264 VAR_OS=linux
13265 VAR_OS_API=posix
13266 VAR_OS_ENV=linux
13267 ;;
13268 *solaris*)
13269 VAR_OS=solaris
13270 VAR_OS_API=posix
13271 VAR_OS_ENV=solaris
13272 ;;
13273 *darwin*)
13274 VAR_OS=macosx
13275 VAR_OS_API=posix
13276 VAR_OS_ENV=macosx
13277 ;;
13278 *bsd*)
13279 VAR_OS=bsd
13280 VAR_OS_API=posix
13281 VAR_OS_ENV=bsd
13282 ;;
13283 *cygwin*)
13284 VAR_OS=windows
13285 VAR_OS_API=winapi
13286 VAR_OS_ENV=windows.cygwin
13287 ;;
13288 *mingw*)
13289 VAR_OS=windows
13290 VAR_OS_API=winapi
13291 VAR_OS_ENV=windows.msys
13292 ;;
13293 *aix*)
13294 VAR_OS=aix
13295 VAR_OS_API=posix
13296 VAR_OS_ENV=aix
13297 ;;
13298 *)
13299 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13300 ;;
13301 esac
13302
13303
13304 # First argument is the cpu name from the trip/quad
13305 case "$build_cpu" in
13306 x86_64)
13307 VAR_CPU=x86_64
13308 VAR_CPU_ARCH=x86
13309 VAR_CPU_BITS=64
13310 VAR_CPU_ENDIAN=little
13311 ;;
13312 i?86)
13313 VAR_CPU=x86
13314 VAR_CPU_ARCH=x86
13315 VAR_CPU_BITS=32
13316 VAR_CPU_ENDIAN=little
13317 ;;
13318 arm*)
13319 VAR_CPU=arm
13320 VAR_CPU_ARCH=arm
13321 VAR_CPU_BITS=32
13322 VAR_CPU_ENDIAN=little
13323 ;;
13324 aarch64)
13325 VAR_CPU=aarch64
13326 VAR_CPU_ARCH=aarch64
13327 VAR_CPU_BITS=64
13328 VAR_CPU_ENDIAN=little
13329 ;;
13330 powerpc)
13331 VAR_CPU=ppc
13332 VAR_CPU_ARCH=ppc
13333 VAR_CPU_BITS=32
13334 VAR_CPU_ENDIAN=big
13335 ;;
13336 powerpc64)
13337 VAR_CPU=ppc64
13338 VAR_CPU_ARCH=ppc
13339 VAR_CPU_BITS=64
13340 VAR_CPU_ENDIAN=big
13341 ;;
13342 powerpc64le)
13343 VAR_CPU=ppc64
13344 VAR_CPU_ARCH=ppc
13345 VAR_CPU_BITS=64
13346 VAR_CPU_ENDIAN=little
13347 ;;
13348 s390)
13349 VAR_CPU=s390
13350 VAR_CPU_ARCH=s390
13351 VAR_CPU_BITS=32
13352 VAR_CPU_ENDIAN=big
13353 ;;
13354 s390x)
13355 VAR_CPU=s390x
13356 VAR_CPU_ARCH=s390
13357 VAR_CPU_BITS=64
13358 VAR_CPU_ENDIAN=big
13359 ;;
13360 sparc)
13361 VAR_CPU=sparc
13362 VAR_CPU_ARCH=sparc
13363 VAR_CPU_BITS=32
13364 VAR_CPU_ENDIAN=big
13365 ;;
13366 sparcv9|sparc64)
13367 VAR_CPU=sparcv9
13368 VAR_CPU_ARCH=sparc
13369 VAR_CPU_BITS=64
13370 VAR_CPU_ENDIAN=big
13371 ;;
13372 *)
13373 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13374 ;;
13375 esac
13376
13377 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13378 OPENJDK_BUILD_OS="$VAR_OS"
13379 OPENJDK_BUILD_OS_API="$VAR_OS_API"
13380 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13381 OPENJDK_BUILD_CPU="$VAR_CPU"
13382 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13383 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13384 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13385
13386
13387
13388
13389
13390
13391
13392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13393 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13394 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13395 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13396
13397 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13398
13399 case "$host_os" in
13400 *linux*)
13401 VAR_OS=linux
13402 VAR_OS_API=posix
13403 VAR_OS_ENV=linux
13404 ;;
13405 *solaris*)
13406 VAR_OS=solaris
13407 VAR_OS_API=posix
13408 VAR_OS_ENV=solaris
13409 ;;
13410 *darwin*)
13411 VAR_OS=macosx
13412 VAR_OS_API=posix
13413 VAR_OS_ENV=macosx
13414 ;;
13415 *bsd*)
13416 VAR_OS=bsd
13417 VAR_OS_API=posix
13418 VAR_OS_ENV=bsd
13419 ;;
13420 *cygwin*)
13421 VAR_OS=windows
13422 VAR_OS_API=winapi
13423 VAR_OS_ENV=windows.cygwin
13424 ;;
13425 *mingw*)
13426 VAR_OS=windows
13427 VAR_OS_API=winapi
13428 VAR_OS_ENV=windows.msys
13429 ;;
13430 *aix*)
13431 VAR_OS=aix
13432 VAR_OS_API=posix
13433 VAR_OS_ENV=aix
13434 ;;
13435 *)
13436 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13437 ;;
13438 esac
13439
13440
13441 # First argument is the cpu name from the trip/quad
13442 case "$host_cpu" in
13443 x86_64)
13444 VAR_CPU=x86_64
13445 VAR_CPU_ARCH=x86
13446 VAR_CPU_BITS=64
13447 VAR_CPU_ENDIAN=little
13448 ;;
13449 i?86)
13450 VAR_CPU=x86
13451 VAR_CPU_ARCH=x86
13452 VAR_CPU_BITS=32
13453 VAR_CPU_ENDIAN=little
13454 ;;
13455 arm*)
13456 VAR_CPU=arm
13457 VAR_CPU_ARCH=arm
13458 VAR_CPU_BITS=32
13459 VAR_CPU_ENDIAN=little
13460 ;;
13461 aarch64)
13462 VAR_CPU=aarch64
13463 VAR_CPU_ARCH=aarch64
13464 VAR_CPU_BITS=64
13465 VAR_CPU_ENDIAN=little
13466 ;;
13467 powerpc)
13468 VAR_CPU=ppc
13469 VAR_CPU_ARCH=ppc
13470 VAR_CPU_BITS=32
13471 VAR_CPU_ENDIAN=big
13472 ;;
13473 powerpc64)
13474 VAR_CPU=ppc64
13475 VAR_CPU_ARCH=ppc
13476 VAR_CPU_BITS=64
13477 VAR_CPU_ENDIAN=big
13478 ;;
13479 powerpc64le)
13480 VAR_CPU=ppc64
13481 VAR_CPU_ARCH=ppc
13482 VAR_CPU_BITS=64
13483 VAR_CPU_ENDIAN=little
13484 ;;
13485 s390)
13486 VAR_CPU=s390
13487 VAR_CPU_ARCH=s390
13488 VAR_CPU_BITS=32
13489 VAR_CPU_ENDIAN=big
13490 ;;
13491 s390x)
13492 VAR_CPU=s390x
13493 VAR_CPU_ARCH=s390
13494 VAR_CPU_BITS=64
13495 VAR_CPU_ENDIAN=big
13496 ;;
13497 sparc)
13498 VAR_CPU=sparc
13499 VAR_CPU_ARCH=sparc
13500 VAR_CPU_BITS=32
13501 VAR_CPU_ENDIAN=big
13502 ;;
13503 sparcv9|sparc64)
13504 VAR_CPU=sparcv9
13505 VAR_CPU_ARCH=sparc
13506 VAR_CPU_BITS=64
13507 VAR_CPU_ENDIAN=big
13508 ;;
13509 *)
13510 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13511 ;;
13512 esac
13513
13514 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13515 OPENJDK_TARGET_OS="$VAR_OS"
13516 OPENJDK_TARGET_OS_API="$VAR_OS_API"
13517 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13518 OPENJDK_TARGET_CPU="$VAR_CPU"
13519 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13520 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13521 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13522
13523
13524
13525
13526
13527
13528
13529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13530 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13531 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13532 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13533
13534
13535
13536 # Check whether --with-target-bits was given.
13537 if test "${with_target_bits+set}" = set; then :
13538 withval=$with_target_bits;
13539 fi
13540
13541
13542 # We have three types of compiles:
13543 # native == normal compilation, target system == build system
13544 # cross == traditional cross compilation, target system != build system; special toolchain needed
13545 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13546 #
13547 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13548 # We're doing a proper cross-compilation
13549 COMPILE_TYPE="cross"
13550 else
13551 COMPILE_TYPE="native"
13552 fi
13553
13554 if test "x$with_target_bits" != x; then
13555 if test "x$COMPILE_TYPE" = "xcross"; then
13556 as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13557 fi
13558
13559 if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13560 # A reduced build is requested
13561 COMPILE_TYPE="reduced"
13562 OPENJDK_TARGET_CPU_BITS=32
13563 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13564 OPENJDK_TARGET_CPU=x86
13565 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13566 OPENJDK_TARGET_CPU=sparc
13567 else
13568 as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13569 fi
13570 elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13571 as_fn_error $? "It is not possible to use --with-target-bits=64 on a 32 bit system. Use proper cross-compilation instead." "$LINENO" 5
13572 elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13573 { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13574 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13575 else
13576 as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13577 fi
13578 fi
13579
13580
13581 { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13582 $as_echo_n "checking compilation type... " >&6; }
13583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13584 $as_echo "$COMPILE_TYPE" >&6; }
13585
13586
13587 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13588 REQUIRED_OS_NAME=SunOS
13589 REQUIRED_OS_VERSION=5.10
13590 fi
13591 if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13592 REQUIRED_OS_NAME=Linux
13593 REQUIRED_OS_VERSION=2.6
13594 fi
13595 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13596 REQUIRED_OS_NAME=Windows
13597 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13598 REQUIRED_OS_VERSION=5.2
13599 else
13600 REQUIRED_OS_VERSION=5.1
13601 fi
13602 fi
13603 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13604 REQUIRED_OS_NAME=Darwin
13605 REQUIRED_OS_VERSION=11.2
13606 fi
13607
13608
13609
13610
13611
13612 # Also store the legacy naming of the cpu.
13613 # Ie i586 and amd64 instead of x86 and x86_64
13614 OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13615 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13616 OPENJDK_TARGET_CPU_LEGACY="i586"
13617 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13618 # On all platforms except MacOSX replace x86_64 with amd64.
13619 OPENJDK_TARGET_CPU_LEGACY="amd64"
13620 fi
13621
13622
13623 # And the second legacy naming of the cpu.
13624 # Ie i386 and amd64 instead of x86 and x86_64.
13625 OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13626 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13627 OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13628 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13629 OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13630 fi
13631
13632
13633 # This is the name of the cpu (but using i386 and amd64 instead of
13634 # x86 and x86_64, respectively), preceeded by a /, to be used when
13635 # locating libraries. On macosx, it's empty, though.
13636 OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13637 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13638 OPENJDK_TARGET_CPU_LIBDIR=""
13639 fi
13640
13641
13642 # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13643 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13644 # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13645 OPENJDK_TARGET_CPU_ISADIR=""
13646 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13647 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13648 OPENJDK_TARGET_CPU_ISADIR="/amd64"
13649 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13650 OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13651 fi
13652 fi
13653
13654
13655 # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13656 OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13657 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13658 # On linux only, we replace x86 with i386.
13659 OPENJDK_TARGET_CPU_OSARCH="i386"
13660 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13661 # On all platforms except macosx, we replace x86_64 with amd64.
13662 OPENJDK_TARGET_CPU_OSARCH="amd64"
13663 fi
13664
13665
13666 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13667 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13668 OPENJDK_TARGET_CPU_JLI="i386"
13669 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13670 # On all platforms except macosx, we replace x86_64 with amd64.
13671 OPENJDK_TARGET_CPU_JLI="amd64"
13672 fi
13673 # Now setup the -D flags for building libjli.
13674 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13675 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13676 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13677 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13678 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13679 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13680 fi
13681 fi
13682
13683
13684 # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
13685 if test "x$OPENJDK_TARGET_OS_API" = xposix; then
13686 OPENJDK_TARGET_OS_API_DIR="solaris"
13687 fi
13688 if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
13689 OPENJDK_TARGET_OS_API_DIR="windows"
13690 fi
13691
13692
13693 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13694 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13695 else
13696 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
13697 fi
13698
13699
13700 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13701 A_LP64="LP64:="
13702 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13703 # unpack200.exe
13704 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13705 ADD_LP64="-D_LP64=1"
13706 fi
13707 fi
13708 LP64=$A_LP64
13709
13710
13711 if test "x$COMPILE_TYPE" = "xcross"; then
13712 # FIXME: ... or should this include reduced builds..?
13713 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13714 else
13715 DEFINE_CROSS_COMPILE_ARCH=""
13716 fi
13717
13718
13719 # ZERO_ARCHDEF is used to enable architecture-specific code
13720 case "${OPENJDK_TARGET_CPU}" in
13721 ppc) ZERO_ARCHDEF=PPC32 ;;
13722 ppc64) ZERO_ARCHDEF=PPC64 ;;
13723 s390*) ZERO_ARCHDEF=S390 ;;
13724 sparc*) ZERO_ARCHDEF=SPARC ;;
13725 x86_64*) ZERO_ARCHDEF=AMD64 ;;
13726 x86) ZERO_ARCHDEF=IA32 ;;
13727 *) ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
13728 esac
13729
13730
13731
13732
13733 # Continue setting up basic stuff. Most remaining code require fundamental tools.
13734
13735 # Locate the directory of this script.
13736 SCRIPT="$0"
13737 AUTOCONF_DIR=`cd \`$DIRNAME $SCRIPT\`; $THEPWDCMD -L`
13738
13739 # Where is the source? It is located two levels above the configure script.
13740 CURDIR="$PWD"
13741 cd "$AUTOCONF_DIR/../.."
13742 SRC_ROOT="`$THEPWDCMD -L`"
13743
13744 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13745 PATH_SEP=";"
13746
13747 SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
13748 if test $SRC_ROOT_LENGTH -gt 100; then
13749 as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
13750 fi
13751
13752 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
13754 $as_echo_n "checking cygwin release... " >&6; }
13755 CYGWIN_VERSION=`$UNAME -r`
13756 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
13757 $as_echo "$CYGWIN_VERSION" >&6; }
13758 WINDOWS_ENV_VENDOR='cygwin'
13759 WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
13760
13761 CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
13762 if test "x$CYGWIN_VERSION_OLD" != x; then
13763 { $as_echo "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
13764 $as_echo "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
13765 as_fn_error $? "Cannot continue" "$LINENO" 5
13766 fi
13767 if test "x$CYGPATH" = x; then
13768 as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
13769 fi
13770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
13771 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
13772 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13773 cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
13774 # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
13775 CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
13776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
13777 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
13778 WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
13779 test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
13780 if test "x$test_cygdrive_prefix" = x; then
13781 as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
13782 fi
13783 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
13785 $as_echo_n "checking msys release... " >&6; }
13786 MSYS_VERSION=`$UNAME -r`
13787 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
13788 $as_echo "$MSYS_VERSION" >&6; }
13789
13790 WINDOWS_ENV_VENDOR='msys'
13791 WINDOWS_ENV_VERSION="$MSYS_VERSION"
13792
13793 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
13794 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
13795 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13796 MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
13797
13798 windows_path="$MSYS_ROOT_PATH"
13799 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13800 unix_path=`$CYGPATH -u "$windows_path"`
13801 MSYS_ROOT_PATH="$unix_path"
13802 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13803 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
13804 MSYS_ROOT_PATH="$unix_path"
13805 fi
13806
13807 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
13808 $as_echo "$MSYS_ROOT_PATH" >&6; }
13809 WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
13810 else
13811 as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
13812 fi
13813
13814 # Test if windows or unix (cygwin/msys) find is first in path.
13815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
13816 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
13817 FIND_BINARY_OUTPUT=`find --version 2>&1`
13818 if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
13819 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
13820 $as_echo "unix style" >&6; }
13821 elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
13822 { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
13823 $as_echo "Windows" >&6; }
13824 { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
13825 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
13826 { $as_echo "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
13827 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
13828 as_fn_error $? "Cannot continue" "$LINENO" 5
13829 else
13830 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
13831 $as_echo "unknown" >&6; }
13832 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
13833 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
13834 fi
13835
13836 else
13837 PATH_SEP=":"
13838 fi
13839
13840
13841
13842 cd "$CURDIR"
13843
13844
13845 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13846
13847 # Input might be given as Windows format, start by converting to
13848 # unix format.
13849 path="$SRC_ROOT"
13850 new_path=`$CYGPATH -u "$path"`
13851
13852 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13853 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13854 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13855 # "foo.exe" is OK but "foo" is an error.
13856 #
13857 # This test is therefore slightly more accurate than "test -f" to check for file precense.
13858 # It is also a way to make sure we got the proper file name for the real test later on.
13859 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
13860 if test "x$test_shortpath" = x; then
13861 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&5
13862 $as_echo "$as_me: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&6;}
13863 as_fn_error $? "Cannot locate the the path of SRC_ROOT" "$LINENO" 5
13864 fi
13865
13866 # Call helper function which possibly converts this using DOS-style short mode.
13867 # If so, the updated path is stored in $new_path.
13868
13869 input_path="$new_path"
13870 # Check if we need to convert this using DOS-style short mode. If the path
13871 # contains just simple characters, use it. Otherwise (spaces, weird characters),
13872 # take no chances and rewrite it.
13873 # Note: m4 eats our [], so we need to use [ and ] instead.
13874 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
13875 if test "x$has_forbidden_chars" != x; then
13876 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
13877 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
13878 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
13879 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
13880 # Going to short mode and back again did indeed matter. Since short mode is
13881 # case insensitive, let's make it lowercase to improve readability.
13882 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
13883 # Now convert it back to Unix-stile (cygpath)
13884 input_path=`$CYGPATH -u "$shortmode_path"`
13885 new_path="$input_path"
13886 fi
13887 fi
13888
13889 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
13890 if test "x$test_cygdrive_prefix" = x; then
13891 # As a simple fix, exclude /usr/bin since it's not a real path.
13892 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
13893 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
13894 # a path prefixed by /cygdrive for fixpath to work.
13895 new_path="$CYGWIN_ROOT_PATH$input_path"
13896 fi
13897 fi
13898
13899
13900 if test "x$path" != "x$new_path"; then
13901 SRC_ROOT="$new_path"
13902 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting SRC_ROOT to \"$new_path\"" >&5
13903 $as_echo "$as_me: Rewriting SRC_ROOT to \"$new_path\"" >&6;}
13904 fi
13905
13906 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13907
13908 path="$SRC_ROOT"
13909 has_colon=`$ECHO $path | $GREP ^.:`
13910 new_path="$path"
13911 if test "x$has_colon" = x; then
13912 # Not in mixed or Windows style, start by that.
13913 new_path=`cmd //c echo $path`
13914 fi
13915
13916
13917 input_path="$new_path"
13918 # Check if we need to convert this using DOS-style short mode. If the path
13919 # contains just simple characters, use it. Otherwise (spaces, weird characters),
13920 # take no chances and rewrite it.
13921 # Note: m4 eats our [], so we need to use [ and ] instead.
13922 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
13923 if test "x$has_forbidden_chars" != x; then
13924 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
13925 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
13926 fi
13927
13928
13929 windows_path="$new_path"
13930 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13931 unix_path=`$CYGPATH -u "$windows_path"`
13932 new_path="$unix_path"
13933 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13934 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
13935 new_path="$unix_path"
13936 fi
13937
13938 if test "x$path" != "x$new_path"; then
13939 SRC_ROOT="$new_path"
13940 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting SRC_ROOT to \"$new_path\"" >&5
13941 $as_echo "$as_me: Rewriting SRC_ROOT to \"$new_path\"" >&6;}
13942 fi
13943
13944 # Save the first 10 bytes of this path to the storage, so fixpath can work.
13945 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
13946
13947 else
13948 # We're on a posix platform. Hooray! :)
13949 path="$SRC_ROOT"
13950 has_space=`$ECHO "$path" | $GREP " "`
13951 if test "x$has_space" != x; then
13952 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&5
13953 $as_echo "$as_me: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&6;}
13954 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
13955 fi
13956
13957 # Use eval to expand a potential ~
13958 eval path="$path"
13959 if test ! -f "$path" && test ! -d "$path"; then
13960 as_fn_error $? "The path of SRC_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
13961 fi
13962
13963 SRC_ROOT="`cd "$path"; $THEPWDCMD -L`"
13964 fi
13965
13966
13967 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13968
13969 # Input might be given as Windows format, start by converting to
13970 # unix format.
13971 path="$CURDIR"
13972 new_path=`$CYGPATH -u "$path"`
13973
13974 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13975 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13976 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13977 # "foo.exe" is OK but "foo" is an error.
13978 #
13979 # This test is therefore slightly more accurate than "test -f" to check for file precense.
13980 # It is also a way to make sure we got the proper file name for the real test later on.
13981 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
13982 if test "x$test_shortpath" = x; then
13983 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
13984 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
13985 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
13986 fi
13987
13988 # Call helper function which possibly converts this using DOS-style short mode.
13989 # If so, the updated path is stored in $new_path.
13990
13991 input_path="$new_path"
13992 # Check if we need to convert this using DOS-style short mode. If the path
13993 # contains just simple characters, use it. Otherwise (spaces, weird characters),
13994 # take no chances and rewrite it.
13995 # Note: m4 eats our [], so we need to use [ and ] instead.
13996 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
13997 if test "x$has_forbidden_chars" != x; then
13998 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
13999 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14000 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14001 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14002 # Going to short mode and back again did indeed matter. Since short mode is
14003 # case insensitive, let's make it lowercase to improve readability.
14004 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14005 # Now convert it back to Unix-stile (cygpath)
14006 input_path=`$CYGPATH -u "$shortmode_path"`
14007 new_path="$input_path"
14008 fi
14009 fi
14010
14011 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14012 if test "x$test_cygdrive_prefix" = x; then
14013 # As a simple fix, exclude /usr/bin since it's not a real path.
14014 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14015 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14016 # a path prefixed by /cygdrive for fixpath to work.
14017 new_path="$CYGWIN_ROOT_PATH$input_path"
14018 fi
14019 fi
14020
14021
14022 if test "x$path" != "x$new_path"; then
14023 CURDIR="$new_path"
14024 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14025 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14026 fi
14027
14028 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14029
14030 path="$CURDIR"
14031 has_colon=`$ECHO $path | $GREP ^.:`
14032 new_path="$path"
14033 if test "x$has_colon" = x; then
14034 # Not in mixed or Windows style, start by that.
14035 new_path=`cmd //c echo $path`
14036 fi
14037
14038
14039 input_path="$new_path"
14040 # Check if we need to convert this using DOS-style short mode. If the path
14041 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14042 # take no chances and rewrite it.
14043 # Note: m4 eats our [], so we need to use [ and ] instead.
14044 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14045 if test "x$has_forbidden_chars" != x; then
14046 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14047 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14048 fi
14049
14050
14051 windows_path="$new_path"
14052 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14053 unix_path=`$CYGPATH -u "$windows_path"`
14054 new_path="$unix_path"
14055 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14056 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14057 new_path="$unix_path"
14058 fi
14059
14060 if test "x$path" != "x$new_path"; then
14061 CURDIR="$new_path"
14062 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14063 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14064 fi
14065
14066 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14067 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14068
14069 else
14070 # We're on a posix platform. Hooray! :)
14071 path="$CURDIR"
14072 has_space=`$ECHO "$path" | $GREP " "`
14073 if test "x$has_space" != x; then
14074 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14075 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14076 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14077 fi
14078
14079 # Use eval to expand a potential ~
14080 eval path="$path"
14081 if test ! -f "$path" && test ! -d "$path"; then
14082 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14083 fi
14084
14085 CURDIR="`cd "$path"; $THEPWDCMD -L`"
14086 fi
14087
14088
14089 if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
14090 # Add extra search paths on solaris for utilities like ar and as etc...
14091 PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
14092 fi
14093
14094 # You can force the sys-root if the sys-root encoded into the cross compiler tools
14095 # is not correct.
14096
14097 # Check whether --with-sys-root was given.
14098 if test "${with_sys_root+set}" = set; then :
14099 withval=$with_sys_root;
14100 fi
14101
14102
14103 if test "x$with_sys_root" != x; then
14104 SYS_ROOT=$with_sys_root
14105 else
14106 SYS_ROOT=/
14107 fi
14108
14109
14110
14111 # Check whether --with-tools-dir was given.
14112 if test "${with_tools_dir+set}" = set; then :
14113 withval=$with_tools_dir; TOOLS_DIR=$with_tools_dir
14114
14115 fi
14116
14117
14118 # Xcode version will be validated later
14119
14120 # Check whether --with-xcode-path was given.
14121 if test "${with_xcode_path+set}" = set; then :
14122 withval=$with_xcode_path; XCODE_PATH=$with_xcode_path
14123
14124 fi
14125
14126
14127
14128 # Check whether --with-devkit was given.
14129 if test "${with_devkit+set}" = set; then :
14130 withval=$with_devkit;
14131 if test "x$with_sys_root" != x; then
14132 as_fn_error $? "Cannot specify both --with-devkit and --with-sys-root at the same time" "$LINENO" 5
14133 fi
14134
14135 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14136
14137 # Input might be given as Windows format, start by converting to
14138 # unix format.
14139 path="$with_devkit"
14140 new_path=`$CYGPATH -u "$path"`
14141
14142 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14143 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14144 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14145 # "foo.exe" is OK but "foo" is an error.
14146 #
14147 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14148 # It is also a way to make sure we got the proper file name for the real test later on.
14149 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14150 if test "x$test_shortpath" = x; then
14151 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14152 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14153 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14154 fi
14155
14156 # Call helper function which possibly converts this using DOS-style short mode.
14157 # If so, the updated path is stored in $new_path.
14158
14159 input_path="$new_path"
14160 # Check if we need to convert this using DOS-style short mode. If the path
14161 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14162 # take no chances and rewrite it.
14163 # Note: m4 eats our [], so we need to use [ and ] instead.
14164 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14165 if test "x$has_forbidden_chars" != x; then
14166 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14167 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14168 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14169 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14170 # Going to short mode and back again did indeed matter. Since short mode is
14171 # case insensitive, let's make it lowercase to improve readability.
14172 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14173 # Now convert it back to Unix-stile (cygpath)
14174 input_path=`$CYGPATH -u "$shortmode_path"`
14175 new_path="$input_path"
14176 fi
14177 fi
14178
14179 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14180 if test "x$test_cygdrive_prefix" = x; then
14181 # As a simple fix, exclude /usr/bin since it's not a real path.
14182 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14183 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14184 # a path prefixed by /cygdrive for fixpath to work.
14185 new_path="$CYGWIN_ROOT_PATH$input_path"
14186 fi
14187 fi
14188
14189
14190 if test "x$path" != "x$new_path"; then
14191 with_devkit="$new_path"
14192 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14193 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14194 fi
14195
14196 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14197
14198 path="$with_devkit"
14199 has_colon=`$ECHO $path | $GREP ^.:`
14200 new_path="$path"
14201 if test "x$has_colon" = x; then
14202 # Not in mixed or Windows style, start by that.
14203 new_path=`cmd //c echo $path`
14204 fi
14205
14206
14207 input_path="$new_path"
14208 # Check if we need to convert this using DOS-style short mode. If the path
14209 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14210 # take no chances and rewrite it.
14211 # Note: m4 eats our [], so we need to use [ and ] instead.
14212 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14213 if test "x$has_forbidden_chars" != x; then
14214 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14215 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14216 fi
14217
14218
14219 windows_path="$new_path"
14220 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14221 unix_path=`$CYGPATH -u "$windows_path"`
14222 new_path="$unix_path"
14223 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14224 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14225 new_path="$unix_path"
14226 fi
14227
14228 if test "x$path" != "x$new_path"; then
14229 with_devkit="$new_path"
14230 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14231 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14232 fi
14233
14234 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14235 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14236
14237 else
14238 # We're on a posix platform. Hooray! :)
14239 path="$with_devkit"
14240 has_space=`$ECHO "$path" | $GREP " "`
14241 if test "x$has_space" != x; then
14242 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14243 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14244 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14245 fi
14246
14247 # Use eval to expand a potential ~
14248 eval path="$path"
14249 if test ! -f "$path" && test ! -d "$path"; then
14250 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14251 fi
14252
14253 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14254 fi
14255
14256
14257 if test "x$TOOLS_DIR" = x; then
14258 TOOLS_DIR="$with_devkit/bin"
14259 else
14260 TOOLS_DIR="$TOOLS_DIR:$with_devkit/bin"
14261 fi
14262
14263 if test -d "$with_devkit/$host_alias/libc"; then
14264 SYS_ROOT=$with_devkit/$host_alias/libc
14265 elif test -d "$with_devkit/$host/sys-root"; then
14266 SYS_ROOT=$with_devkit/$host/sys-root
14267 fi
14268
14269 fi
14270
14271
14272
14273 # Setup default logging of stdout and stderr to build.log in the output root.
14274 BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14275 BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14276 BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14277
14278
14279
14280
14281
14282 # Check if it's a pure open build or if custom sources are to be used.
14283
14284 # Check whether --enable-openjdk-only was given.
14285 if test "${enable_openjdk_only+set}" = set; then :
14286 enableval=$enable_openjdk_only;
14287 else
14288 enable_openjdk_only="no"
14289 fi
14290
14291
14292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14293 $as_echo_n "checking for presence of closed sources... " >&6; }
14294 if test -d "$SRC_ROOT/jdk/src/closed"; then
14295 CLOSED_SOURCE_PRESENT=yes
14296 else
14297 CLOSED_SOURCE_PRESENT=no
14298 fi
14299 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14300 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14301
14302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14303 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14304 SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14306 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14307
14308 if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14309 OPENJDK=true
14310 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14311 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14312 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14313 fi
14314 else
14315 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14316 OPENJDK=true
14317 else
14318 OPENJDK=false
14319 fi
14320 fi
14321
14322 if test "x$OPENJDK" = "xtrue"; then
14323 SET_OPENJDK="OPENJDK=true"
14324 fi
14325
14326
14327
14328
14329 # These are needed to be able to create a configuration name (and thus the output directory)
14330
14331 ###############################################################################
14332 #
14333 # Check which variant of the JDK that we want to build.
14334 # Currently we have:
14335 # normal: standard edition
14336 # but the custom make system may add other variants
14337 #
14338 # Effectively the JDK variant gives a name to a specific set of
14339 # modules to compile into the JDK. In the future, these modules
14340 # might even be Jigsaw modules.
14341 #
14342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14343 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14344
14345 # Check whether --with-jdk-variant was given.
14346 if test "${with_jdk_variant+set}" = set; then :
14347 withval=$with_jdk_variant;
14348 fi
14349
14350
14351 if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14352 JDK_VARIANT="normal"
14353 else
14354 as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14355 fi
14356
14357
14358
14359 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14360 $as_echo "$JDK_VARIANT" >&6; }
14361
14362
14363 ###############################################################################
14364 #
14365 # Check which interpreter of the JVM we want to build.
14366 # Currently we have:
14367 # template: Template interpreter (the default)
14368 # cpp : C++ interpreter
14369 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14370 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14371
14372 # Check whether --with-jvm-interpreter was given.
14373 if test "${with_jvm_interpreter+set}" = set; then :
14374 withval=$with_jvm_interpreter;
14375 fi
14376
14377
14378 if test "x$with_jvm_interpreter" = x; then
14379 with_jvm_interpreter="template"
14380 fi
14381
14382 JVM_INTERPRETER="$with_jvm_interpreter"
14383
14384 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14385 as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14386 fi
14387
14388
14389
14390 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14391 $as_echo "$with_jvm_interpreter" >&6; }
14392
14393
14394
14395 ###############################################################################
14396 #
14397 # Check which variants of the JVM that we want to build.
14398 # Currently we have:
14399 # server: normal interpreter and a tiered C1/C2 compiler
14400 # client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14401 # minimal1: reduced form of client with optional VM services and features stripped out
14402 # kernel: kernel footprint JVM that passes the TCK without major performance problems,
14403 # ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14404 # zero: no machine code interpreter, no compiler
14405 # zeroshark: zero interpreter and shark/llvm compiler backend
14406 # core: interpreter only, no compiler (only works on some platforms)
14407 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14408 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14409
14410 # Check whether --with-jvm-variants was given.
14411 if test "${with_jvm_variants+set}" = set; then :
14412 withval=$with_jvm_variants;
14413 fi
14414
14415
14416 if test "x$with_jvm_variants" = x; then
14417 with_jvm_variants="server"
14418 fi
14419
14420 JVM_VARIANTS=",$with_jvm_variants,"
14421 TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/minimal1,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//' -e 's/core,//'`
14422
14423 if test "x$TEST_VARIANTS" != "x,"; then
14424 as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14425 fi
14426 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14427 $as_echo "$with_jvm_variants" >&6; }
14428
14429 JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14430 JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14431 JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14432 JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14433 JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14434 JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14435 JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14436
14437 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14438 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14439 as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14440 fi
14441 fi
14442 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14443 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14444 as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14445 fi
14446 fi
14447 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14448 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14449 as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14450 fi
14451 fi
14452
14453 # Replace the commas with AND for use in the build directory name.
14454 ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14455 COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/minimal1,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/' -e 's/core,/1/'`
14456 if test "x$COUNT_VARIANTS" != "x,1"; then
14457 BUILDING_MULTIPLE_JVM_VARIANTS=yes
14458 else
14459 BUILDING_MULTIPLE_JVM_VARIANTS=no
14460 fi
14461
14462
14463
14464
14465
14466
14467
14468
14469
14470
14471 INCLUDE_SA=true
14472 if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14473 INCLUDE_SA=false
14474 fi
14475 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14476 INCLUDE_SA=false
14477 fi
14478 if test "x$VAR_CPU" = xppc64 ; then
14479 INCLUDE_SA=false
14480 fi
14481 if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
14482 INCLUDE_SA=false
14483 fi
14484
14485
14486 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14487 MACOSX_UNIVERSAL="false"
14488 fi
14489
14490
14491
14492
14493 ###############################################################################
14494 #
14495 # Set the debug level
14496 # release: no debug information, all optimizations, no asserts.
14497 # fastdebug: debug information (-g), all optimizations, all asserts
14498 # slowdebug: debug information (-g), no optimizations, all asserts
14499 #
14500 DEBUG_LEVEL="release"
14501 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14502 $as_echo_n "checking which debug level to use... " >&6; }
14503 # Check whether --enable-debug was given.
14504 if test "${enable_debug+set}" = set; then :
14505 enableval=$enable_debug;
14506 ENABLE_DEBUG="${enableval}"
14507 DEBUG_LEVEL="fastdebug"
14508
14509 else
14510 ENABLE_DEBUG="no"
14511 fi
14512
14513
14514
14515 # Check whether --with-debug-level was given.
14516 if test "${with_debug_level+set}" = set; then :
14517 withval=$with_debug_level;
14518 DEBUG_LEVEL="${withval}"
14519 if test "x$ENABLE_DEBUG" = xyes; then
14520 as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14521 fi
14522
14523 fi
14524
14525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14526 $as_echo "$DEBUG_LEVEL" >&6; }
14527
14528 if test "x$DEBUG_LEVEL" != xrelease && \
14529 test "x$DEBUG_LEVEL" != xfastdebug && \
14530 test "x$DEBUG_LEVEL" != xslowdebug; then
14531 as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14532 fi
14533
14534
14535 ###############################################################################
14536 #
14537 # Setup legacy vars/targets and new vars to deal with different debug levels.
14538 #
14539
14540 case $DEBUG_LEVEL in
14541 release )
14542 VARIANT="OPT"
14543 FASTDEBUG="false"
14544 DEBUG_CLASSFILES="false"
14545 BUILD_VARIANT_RELEASE=""
14546 HOTSPOT_DEBUG_LEVEL="product"
14547 HOTSPOT_EXPORT="product"
14548 ;;
14549 fastdebug )
14550 VARIANT="DBG"
14551 FASTDEBUG="true"
14552 DEBUG_CLASSFILES="true"
14553 BUILD_VARIANT_RELEASE="-fastdebug"
14554 HOTSPOT_DEBUG_LEVEL="fastdebug"
14555 HOTSPOT_EXPORT="fastdebug"
14556 ;;
14557 slowdebug )
14558 VARIANT="DBG"
14559 FASTDEBUG="false"
14560 DEBUG_CLASSFILES="true"
14561 BUILD_VARIANT_RELEASE="-debug"
14562 HOTSPOT_DEBUG_LEVEL="jvmg"
14563 HOTSPOT_EXPORT="debug"
14564 ;;
14565 esac
14566
14567 #####
14568 # Generate the legacy makefile targets for hotspot.
14569 # The hotspot api for selecting the build artifacts, really, needs to be improved.
14570 # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14571 # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14572 # But until then ...
14573 HOTSPOT_TARGET=""
14574
14575 if test "x$JVM_VARIANT_SERVER" = xtrue; then
14576 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14577 fi
14578
14579 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14580 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14581 fi
14582
14583 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14584 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14585 fi
14586
14587 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14588 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14589 fi
14590
14591 if test "x$JVM_VARIANT_ZERO" = xtrue; then
14592 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14593 fi
14594
14595 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14596 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14597 fi
14598
14599 if test "x$JVM_VARIANT_CORE" = xtrue; then
14600 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14601 fi
14602
14603 HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14604
14605 # On Macosx universal binaries are produced, but they only contain
14606 # 64 bit intel. This invalidates control of which jvms are built
14607 # from configure, but only server is valid anyway. Fix this
14608 # when hotspot makefiles are rewritten.
14609 if test "x$MACOSX_UNIVERSAL" = xtrue; then
14610 HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14611 fi
14612
14613 #####
14614
14615
14616
14617
14618
14619
14620
14621
14622 # With basic setup done, call the custom early hook.
14623
14624
14625 # To properly create a configuration name, we need to have the OpenJDK target
14626 # and options (variants and debug level) parsed.
14627
14628
14629
14630 # Check whether --with-conf-name was given.
14631 if test "${with_conf_name+set}" = set; then :
14632 withval=$with_conf_name; CONF_NAME=${with_conf_name}
14633 fi
14634
14635
14636 # Test from where we are running configure, in or outside of src root.
14637 if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
14638 || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
14639 || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
14640 # We are running configure from the src root.
14641 # Create a default ./build/target-variant-debuglevel output root.
14642 if test "x${CONF_NAME}" = x; then
14643 CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
14644 fi
14645 OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
14646 $MKDIR -p "$OUTPUT_ROOT"
14647 if test ! -d "$OUTPUT_ROOT"; then
14648 as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
14649 fi
14650 else
14651 # We are running configure from outside of the src dir.
14652 # Then use the current directory as output dir!
14653 # If configuration is situated in normal build directory, just use the build
14654 # directory name as configuration name, otherwise use the complete path.
14655 if test "x${CONF_NAME}" = x; then
14656 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
14657 fi
14658 OUTPUT_ROOT="$CURDIR"
14659
14660 # WARNING: This might be a bad thing to do. You need to be sure you want to
14661 # have a configuration in this directory. Do some sanity checks!
14662
14663 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
14664 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
14665 # other files
14666 files_present=`$LS $OUTPUT_ROOT`
14667 # Configure has already touched config.log and confdefs.h in the current dir when this check
14668 # is performed.
14669 filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
14670 | $TR -d '\n'`
14671 if test "x$filtered_files" != x; then
14672 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
14673 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
14674 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
14675 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
14676 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
14677 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
14678 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
14679 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
14680 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
14681 $as_echo "$as_me: seriously mess up just about everything." >&6;}
14682 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
14683 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
14684 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
14685 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
14686 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
14687 fi
14688 fi
14689 fi
14690 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
14691 $as_echo_n "checking what configuration name to use... " >&6; }
14692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
14693 $as_echo "$CONF_NAME" >&6; }
14694
14695
14696 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14697
14698 # Input might be given as Windows format, start by converting to
14699 # unix format.
14700 path="$OUTPUT_ROOT"
14701 new_path=`$CYGPATH -u "$path"`
14702
14703 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14704 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14705 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14706 # "foo.exe" is OK but "foo" is an error.
14707 #
14708 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14709 # It is also a way to make sure we got the proper file name for the real test later on.
14710 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14711 if test "x$test_shortpath" = x; then
14712 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
14713 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
14714 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
14715 fi
14716
14717 # Call helper function which possibly converts this using DOS-style short mode.
14718 # If so, the updated path is stored in $new_path.
14719
14720 input_path="$new_path"
14721 # Check if we need to convert this using DOS-style short mode. If the path
14722 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14723 # take no chances and rewrite it.
14724 # Note: m4 eats our [], so we need to use [ and ] instead.
14725 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14726 if test "x$has_forbidden_chars" != x; then
14727 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14728 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14729 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14730 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14731 # Going to short mode and back again did indeed matter. Since short mode is
14732 # case insensitive, let's make it lowercase to improve readability.
14733 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14734 # Now convert it back to Unix-stile (cygpath)
14735 input_path=`$CYGPATH -u "$shortmode_path"`
14736 new_path="$input_path"
14737 fi
14738 fi
14739
14740 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14741 if test "x$test_cygdrive_prefix" = x; then
14742 # As a simple fix, exclude /usr/bin since it's not a real path.
14743 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14744 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14745 # a path prefixed by /cygdrive for fixpath to work.
14746 new_path="$CYGWIN_ROOT_PATH$input_path"
14747 fi
14748 fi
14749
14750
14751 if test "x$path" != "x$new_path"; then
14752 OUTPUT_ROOT="$new_path"
14753 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
14754 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
14755 fi
14756
14757 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14758
14759 path="$OUTPUT_ROOT"
14760 has_colon=`$ECHO $path | $GREP ^.:`
14761 new_path="$path"
14762 if test "x$has_colon" = x; then
14763 # Not in mixed or Windows style, start by that.
14764 new_path=`cmd //c echo $path`
14765 fi
14766
14767
14768 input_path="$new_path"
14769 # Check if we need to convert this using DOS-style short mode. If the path
14770 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14771 # take no chances and rewrite it.
14772 # Note: m4 eats our [], so we need to use [ and ] instead.
14773 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14774 if test "x$has_forbidden_chars" != x; then
14775 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14776 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14777 fi
14778
14779
14780 windows_path="$new_path"
14781 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14782 unix_path=`$CYGPATH -u "$windows_path"`
14783 new_path="$unix_path"
14784 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14785 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14786 new_path="$unix_path"
14787 fi
14788
14789 if test "x$path" != "x$new_path"; then
14790 OUTPUT_ROOT="$new_path"
14791 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
14792 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
14793 fi
14794
14795 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14796 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14797
14798 else
14799 # We're on a posix platform. Hooray! :)
14800 path="$OUTPUT_ROOT"
14801 has_space=`$ECHO "$path" | $GREP " "`
14802 if test "x$has_space" != x; then
14803 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
14804 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
14805 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14806 fi
14807
14808 # Use eval to expand a potential ~
14809 eval path="$path"
14810 if test ! -f "$path" && test ! -d "$path"; then
14811 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
14812 fi
14813
14814 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
14815 fi
14816
14817
14818 SPEC=$OUTPUT_ROOT/spec.gmk
14819
14820 CONF_NAME=$CONF_NAME
14821
14822 OUTPUT_ROOT=$OUTPUT_ROOT
14823
14824
14825 # Most of the probed defines are put into config.h
14826 ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in"
14827
14828 # The spec.gmk file contains all variables for the make system.
14829 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
14830
14831 # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
14832 ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
14833
14834 # The bootcycle-spec.gmk file contains support for boot cycle builds.
14835 ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
14836
14837 # The compare.sh is used to compare the build output to other builds.
14838 ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
14839
14840 # Spec.sh is currently used by compare-objects.sh
14841 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in"
14842
14843 # The generated Makefile knows where the spec.gmk is and where the source is.
14844 # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
14845 # which will look for generated configurations
14846 ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
14847
14848
14849 # Save the arguments given to us
14850 echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments
14851
14852
14853 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
14854
14855 for ac_prog in apt-get yum port pkgutil pkgadd
14856 do
14857 # Extract the first word of "$ac_prog", so it can be a program name with args.
14858 set dummy $ac_prog; ac_word=$2
14859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14860 $as_echo_n "checking for $ac_word... " >&6; }
14861 if ${ac_cv_prog_PKGHANDLER+:} false; then :
14862 $as_echo_n "(cached) " >&6
14863 else
14864 if test -n "$PKGHANDLER"; then
14865 ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
14866 else
14867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14868 for as_dir in $PATH
14869 do
14870 IFS=$as_save_IFS
14871 test -z "$as_dir" && as_dir=.
14872 for ac_exec_ext in '' $ac_executable_extensions; do
14873 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14874 ac_cv_prog_PKGHANDLER="$ac_prog"
14875 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14876 break 2
14877 fi
14878 done
14879 done
14880 IFS=$as_save_IFS
14881
14882 fi
14883 fi
14884 PKGHANDLER=$ac_cv_prog_PKGHANDLER
14885 if test -n "$PKGHANDLER"; then
14886 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
14887 $as_echo "$PKGHANDLER" >&6; }
14888 else
14889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14890 $as_echo "no" >&6; }
14891 fi
14892
14893
14894 test -n "$PKGHANDLER" && break
14895 done
14896
14897
14898
14899 # Setup tools that requires more complex handling, or that is not needed by the configure script.
14900
14901
14902 # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
14903 if test "x$MAKE" != x; then
14904 # User has supplied a make, test it.
14905 if test ! -f "$MAKE"; then
14906 as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
14907 fi
14908
14909 MAKE_CANDIDATE=""$MAKE""
14910 DESCRIPTION="user supplied MAKE=$MAKE"
14911 if test "x$MAKE_CANDIDATE" != x; then
14912 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
14913 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
14914 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
14915 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
14916 if test "x$IS_GNU_MAKE" = x; then
14917 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
14918 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
14919 else
14920 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
14921 if test "x$IS_MODERN_MAKE" = x; then
14922 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
14923 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
14924 else
14925 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
14926 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14927 MAKE_EXPECTED_ENV='cygwin'
14928 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14929 MAKE_EXPECTED_ENV='msys'
14930 else
14931 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
14932 fi
14933 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
14934 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
14935 else
14936 # Not relevant for non-Windows
14937 IS_MAKE_CORRECT_ENV=true
14938 fi
14939 if test "x$IS_MAKE_CORRECT_ENV" = x; then
14940 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
14941 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
14942 else
14943 FOUND_MAKE=$MAKE_CANDIDATE
14944
14945 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14946
14947 # First separate the path from the arguments. This will split at the first
14948 # space.
14949 complete="$FOUND_MAKE"
14950 path="${complete%% *}"
14951 tmp="$complete EOL"
14952 arguments="${tmp#* }"
14953
14954 # Input might be given as Windows format, start by converting to
14955 # unix format.
14956 new_path=`$CYGPATH -u "$path"`
14957
14958 # Now try to locate executable using which
14959 new_path=`$WHICH "$new_path" 2> /dev/null`
14960 # bat and cmd files are not always considered executable in cygwin causing which
14961 # to not find them
14962 if test "x$new_path" = x \
14963 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
14964 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
14965 new_path=`$CYGPATH -u "$path"`
14966 fi
14967 if test "x$new_path" = x; then
14968 # Oops. Which didn't find the executable.
14969 # The splitting of arguments from the executable at a space might have been incorrect,
14970 # since paths with space are more likely in Windows. Give it another try with the whole
14971 # argument.
14972 path="$complete"
14973 arguments="EOL"
14974 new_path=`$CYGPATH -u "$path"`
14975 new_path=`$WHICH "$new_path" 2> /dev/null`
14976 # bat and cmd files are not always considered executable in cygwin causing which
14977 # to not find them
14978 if test "x$new_path" = x \
14979 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
14980 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
14981 new_path=`$CYGPATH -u "$path"`
14982 fi
14983 if test "x$new_path" = x; then
14984 # It's still not found. Now this is an unrecoverable error.
14985 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
14986 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
14987 has_space=`$ECHO "$complete" | $GREP " "`
14988 if test "x$has_space" != x; then
14989 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
14990 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
14991 fi
14992 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
14993 fi
14994 fi
14995
14996 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14997 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14998 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14999 # "foo.exe" is OK but "foo" is an error.
15000 #
15001 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15002 # It is also a way to make sure we got the proper file name for the real test later on.
15003 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15004 if test "x$test_shortpath" = x; then
15005 # Short path failed, file does not exist as specified.
15006 # Try adding .exe or .cmd
15007 if test -f "${new_path}.exe"; then
15008 input_to_shortpath="${new_path}.exe"
15009 elif test -f "${new_path}.cmd"; then
15010 input_to_shortpath="${new_path}.cmd"
15011 else
15012 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15013 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15014 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15015 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15016 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15017 fi
15018 else
15019 input_to_shortpath="$new_path"
15020 fi
15021
15022 # Call helper function which possibly converts this using DOS-style short mode.
15023 # If so, the updated path is stored in $new_path.
15024 new_path="$input_to_shortpath"
15025
15026 input_path="$input_to_shortpath"
15027 # Check if we need to convert this using DOS-style short mode. If the path
15028 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15029 # take no chances and rewrite it.
15030 # Note: m4 eats our [], so we need to use [ and ] instead.
15031 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15032 if test "x$has_forbidden_chars" != x; then
15033 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15034 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15035 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15036 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15037 # Going to short mode and back again did indeed matter. Since short mode is
15038 # case insensitive, let's make it lowercase to improve readability.
15039 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15040 # Now convert it back to Unix-stile (cygpath)
15041 input_path=`$CYGPATH -u "$shortmode_path"`
15042 new_path="$input_path"
15043 fi
15044 fi
15045
15046 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15047 if test "x$test_cygdrive_prefix" = x; then
15048 # As a simple fix, exclude /usr/bin since it's not a real path.
15049 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15050 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15051 # a path prefixed by /cygdrive for fixpath to work.
15052 new_path="$CYGWIN_ROOT_PATH$input_path"
15053 fi
15054 fi
15055
15056 # remove trailing .exe if any
15057 new_path="${new_path/%.exe/}"
15058
15059 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15060
15061 # First separate the path from the arguments. This will split at the first
15062 # space.
15063 complete="$FOUND_MAKE"
15064 path="${complete%% *}"
15065 tmp="$complete EOL"
15066 arguments="${tmp#* }"
15067
15068 # Input might be given as Windows format, start by converting to
15069 # unix format.
15070 new_path="$path"
15071
15072 windows_path="$new_path"
15073 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15074 unix_path=`$CYGPATH -u "$windows_path"`
15075 new_path="$unix_path"
15076 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15077 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15078 new_path="$unix_path"
15079 fi
15080
15081
15082 # Now try to locate executable using which
15083 new_path=`$WHICH "$new_path" 2> /dev/null`
15084
15085 if test "x$new_path" = x; then
15086 # Oops. Which didn't find the executable.
15087 # The splitting of arguments from the executable at a space might have been incorrect,
15088 # since paths with space are more likely in Windows. Give it another try with the whole
15089 # argument.
15090 path="$complete"
15091 arguments="EOL"
15092 new_path="$path"
15093
15094 windows_path="$new_path"
15095 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15096 unix_path=`$CYGPATH -u "$windows_path"`
15097 new_path="$unix_path"
15098 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15099 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15100 new_path="$unix_path"
15101 fi
15102
15103
15104 new_path=`$WHICH "$new_path" 2> /dev/null`
15105
15106 if test "x$new_path" = x; then
15107 # It's still not found. Now this is an unrecoverable error.
15108 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15109 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15110 has_space=`$ECHO "$complete" | $GREP " "`
15111 if test "x$has_space" != x; then
15112 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15113 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15114 fi
15115 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15116 fi
15117 fi
15118
15119 # Now new_path has a complete unix path to the binary
15120 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15121 # Keep paths in /bin as-is, but remove trailing .exe if any
15122 new_path="${new_path/%.exe/}"
15123 # Do not save /bin paths to all_fixpath_prefixes!
15124 else
15125 # Not in mixed or Windows style, start by that.
15126 new_path=`cmd //c echo $new_path`
15127
15128 input_path="$new_path"
15129 # Check if we need to convert this using DOS-style short mode. If the path
15130 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15131 # take no chances and rewrite it.
15132 # Note: m4 eats our [], so we need to use [ and ] instead.
15133 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15134 if test "x$has_forbidden_chars" != x; then
15135 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15136 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15137 fi
15138
15139 # Output is in $new_path
15140
15141 windows_path="$new_path"
15142 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15143 unix_path=`$CYGPATH -u "$windows_path"`
15144 new_path="$unix_path"
15145 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15146 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15147 new_path="$unix_path"
15148 fi
15149
15150 # remove trailing .exe if any
15151 new_path="${new_path/%.exe/}"
15152
15153 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15154 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15155 fi
15156
15157 else
15158 # We're on a posix platform. Hooray! :)
15159 # First separate the path from the arguments. This will split at the first
15160 # space.
15161 complete="$FOUND_MAKE"
15162 path="${complete%% *}"
15163 tmp="$complete EOL"
15164 arguments="${tmp#* }"
15165
15166 # Cannot rely on the command "which" here since it doesn't always work.
15167 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15168 if test -z "$is_absolute_path"; then
15169 # Path to executable is not absolute. Find it.
15170 IFS_save="$IFS"
15171 IFS=:
15172 for p in $PATH; do
15173 if test -f "$p/$path" && test -x "$p/$path"; then
15174 new_path="$p/$path"
15175 break
15176 fi
15177 done
15178 IFS="$IFS_save"
15179 else
15180 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
15181 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
15182 new_path="$path"
15183 fi
15184
15185 if test "x$new_path" = x; then
15186 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15187 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15188 has_space=`$ECHO "$complete" | $GREP " "`
15189 if test "x$has_space" != x; then
15190 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15191 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15192 fi
15193 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15194 fi
15195 fi
15196
15197 # Now join together the path and the arguments once again
15198 if test "x$arguments" != xEOL; then
15199 new_complete="$new_path ${arguments% *}"
15200 else
15201 new_complete="$new_path"
15202 fi
15203
15204 if test "x$complete" != "x$new_complete"; then
15205 FOUND_MAKE="$new_complete"
15206 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15207 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15208 fi
15209
15210 fi
15211 fi
15212 fi
15213 fi
15214
15215 if test "x$FOUND_MAKE" = x; then
15216 as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15217 fi
15218 else
15219 # Try our hardest to locate a correct version of GNU make
15220 for ac_prog in gmake
15221 do
15222 # Extract the first word of "$ac_prog", so it can be a program name with args.
15223 set dummy $ac_prog; ac_word=$2
15224 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15225 $as_echo_n "checking for $ac_word... " >&6; }
15226 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15227 $as_echo_n "(cached) " >&6
15228 else
15229 case $CHECK_GMAKE in
15230 [\\/]* | ?:[\\/]*)
15231 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15232 ;;
15233 *)
15234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15235 for as_dir in $PATH
15236 do
15237 IFS=$as_save_IFS
15238 test -z "$as_dir" && as_dir=.
15239 for ac_exec_ext in '' $ac_executable_extensions; do
15240 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15241 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15242 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15243 break 2
15244 fi
15245 done
15246 done
15247 IFS=$as_save_IFS
15248
15249 ;;
15250 esac
15251 fi
15252 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15253 if test -n "$CHECK_GMAKE"; then
15254 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15255 $as_echo "$CHECK_GMAKE" >&6; }
15256 else
15257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15258 $as_echo "no" >&6; }
15259 fi
15260
15261
15262 test -n "$CHECK_GMAKE" && break
15263 done
15264
15265
15266 MAKE_CANDIDATE=""$CHECK_GMAKE""
15267 DESCRIPTION="gmake in PATH"
15268 if test "x$MAKE_CANDIDATE" != x; then
15269 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15270 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15271 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15272 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15273 if test "x$IS_GNU_MAKE" = x; then
15274 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15275 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15276 else
15277 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15278 if test "x$IS_MODERN_MAKE" = x; then
15279 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15280 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15281 else
15282 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15283 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15284 MAKE_EXPECTED_ENV='cygwin'
15285 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15286 MAKE_EXPECTED_ENV='msys'
15287 else
15288 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15289 fi
15290 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15291 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15292 else
15293 # Not relevant for non-Windows
15294 IS_MAKE_CORRECT_ENV=true
15295 fi
15296 if test "x$IS_MAKE_CORRECT_ENV" = x; then
15297 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
15298 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
15299 else
15300 FOUND_MAKE=$MAKE_CANDIDATE
15301
15302 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15303
15304 # First separate the path from the arguments. This will split at the first
15305 # space.
15306 complete="$FOUND_MAKE"
15307 path="${complete%% *}"
15308 tmp="$complete EOL"
15309 arguments="${tmp#* }"
15310
15311 # Input might be given as Windows format, start by converting to
15312 # unix format.
15313 new_path=`$CYGPATH -u "$path"`
15314
15315 # Now try to locate executable using which
15316 new_path=`$WHICH "$new_path" 2> /dev/null`
15317 # bat and cmd files are not always considered executable in cygwin causing which
15318 # to not find them
15319 if test "x$new_path" = x \
15320 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15321 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15322 new_path=`$CYGPATH -u "$path"`
15323 fi
15324 if test "x$new_path" = x; then
15325 # Oops. Which didn't find the executable.
15326 # The splitting of arguments from the executable at a space might have been incorrect,
15327 # since paths with space are more likely in Windows. Give it another try with the whole
15328 # argument.
15329 path="$complete"
15330 arguments="EOL"
15331 new_path=`$CYGPATH -u "$path"`
15332 new_path=`$WHICH "$new_path" 2> /dev/null`
15333 # bat and cmd files are not always considered executable in cygwin causing which
15334 # to not find them
15335 if test "x$new_path" = x \
15336 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15337 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15338 new_path=`$CYGPATH -u "$path"`
15339 fi
15340 if test "x$new_path" = x; then
15341 # It's still not found. Now this is an unrecoverable error.
15342 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15343 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15344 has_space=`$ECHO "$complete" | $GREP " "`
15345 if test "x$has_space" != x; then
15346 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15347 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15348 fi
15349 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15350 fi
15351 fi
15352
15353 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15354 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15355 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15356 # "foo.exe" is OK but "foo" is an error.
15357 #
15358 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15359 # It is also a way to make sure we got the proper file name for the real test later on.
15360 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15361 if test "x$test_shortpath" = x; then
15362 # Short path failed, file does not exist as specified.
15363 # Try adding .exe or .cmd
15364 if test -f "${new_path}.exe"; then
15365 input_to_shortpath="${new_path}.exe"
15366 elif test -f "${new_path}.cmd"; then
15367 input_to_shortpath="${new_path}.cmd"
15368 else
15369 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15370 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15371 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15372 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15373 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15374 fi
15375 else
15376 input_to_shortpath="$new_path"
15377 fi
15378
15379 # Call helper function which possibly converts this using DOS-style short mode.
15380 # If so, the updated path is stored in $new_path.
15381 new_path="$input_to_shortpath"
15382
15383 input_path="$input_to_shortpath"
15384 # Check if we need to convert this using DOS-style short mode. If the path
15385 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15386 # take no chances and rewrite it.
15387 # Note: m4 eats our [], so we need to use [ and ] instead.
15388 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15389 if test "x$has_forbidden_chars" != x; then
15390 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15391 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15392 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15393 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15394 # Going to short mode and back again did indeed matter. Since short mode is
15395 # case insensitive, let's make it lowercase to improve readability.
15396 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15397 # Now convert it back to Unix-stile (cygpath)
15398 input_path=`$CYGPATH -u "$shortmode_path"`
15399 new_path="$input_path"
15400 fi
15401 fi
15402
15403 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15404 if test "x$test_cygdrive_prefix" = x; then
15405 # As a simple fix, exclude /usr/bin since it's not a real path.
15406 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15407 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15408 # a path prefixed by /cygdrive for fixpath to work.
15409 new_path="$CYGWIN_ROOT_PATH$input_path"
15410 fi
15411 fi
15412
15413 # remove trailing .exe if any
15414 new_path="${new_path/%.exe/}"
15415
15416 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15417
15418 # First separate the path from the arguments. This will split at the first
15419 # space.
15420 complete="$FOUND_MAKE"
15421 path="${complete%% *}"
15422 tmp="$complete EOL"
15423 arguments="${tmp#* }"
15424
15425 # Input might be given as Windows format, start by converting to
15426 # unix format.
15427 new_path="$path"
15428
15429 windows_path="$new_path"
15430 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15431 unix_path=`$CYGPATH -u "$windows_path"`
15432 new_path="$unix_path"
15433 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15434 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15435 new_path="$unix_path"
15436 fi
15437
15438
15439 # Now try to locate executable using which
15440 new_path=`$WHICH "$new_path" 2> /dev/null`
15441
15442 if test "x$new_path" = x; then
15443 # Oops. Which didn't find the executable.
15444 # The splitting of arguments from the executable at a space might have been incorrect,
15445 # since paths with space are more likely in Windows. Give it another try with the whole
15446 # argument.
15447 path="$complete"
15448 arguments="EOL"
15449 new_path="$path"
15450
15451 windows_path="$new_path"
15452 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15453 unix_path=`$CYGPATH -u "$windows_path"`
15454 new_path="$unix_path"
15455 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15456 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15457 new_path="$unix_path"
15458 fi
15459
15460
15461 new_path=`$WHICH "$new_path" 2> /dev/null`
15462
15463 if test "x$new_path" = x; then
15464 # It's still not found. Now this is an unrecoverable error.
15465 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15466 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15467 has_space=`$ECHO "$complete" | $GREP " "`
15468 if test "x$has_space" != x; then
15469 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15470 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15471 fi
15472 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15473 fi
15474 fi
15475
15476 # Now new_path has a complete unix path to the binary
15477 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15478 # Keep paths in /bin as-is, but remove trailing .exe if any
15479 new_path="${new_path/%.exe/}"
15480 # Do not save /bin paths to all_fixpath_prefixes!
15481 else
15482 # Not in mixed or Windows style, start by that.
15483 new_path=`cmd //c echo $new_path`
15484
15485 input_path="$new_path"
15486 # Check if we need to convert this using DOS-style short mode. If the path
15487 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15488 # take no chances and rewrite it.
15489 # Note: m4 eats our [], so we need to use [ and ] instead.
15490 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15491 if test "x$has_forbidden_chars" != x; then
15492 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15493 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15494 fi
15495
15496 # Output is in $new_path
15497
15498 windows_path="$new_path"
15499 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15500 unix_path=`$CYGPATH -u "$windows_path"`
15501 new_path="$unix_path"
15502 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15503 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15504 new_path="$unix_path"
15505 fi
15506
15507 # remove trailing .exe if any
15508 new_path="${new_path/%.exe/}"
15509
15510 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15511 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15512 fi
15513
15514 else
15515 # We're on a posix platform. Hooray! :)
15516 # First separate the path from the arguments. This will split at the first
15517 # space.
15518 complete="$FOUND_MAKE"
15519 path="${complete%% *}"
15520 tmp="$complete EOL"
15521 arguments="${tmp#* }"
15522
15523 # Cannot rely on the command "which" here since it doesn't always work.
15524 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15525 if test -z "$is_absolute_path"; then
15526 # Path to executable is not absolute. Find it.
15527 IFS_save="$IFS"
15528 IFS=:
15529 for p in $PATH; do
15530 if test -f "$p/$path" && test -x "$p/$path"; then
15531 new_path="$p/$path"
15532 break
15533 fi
15534 done
15535 IFS="$IFS_save"
15536 else
15537 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
15538 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
15539 new_path="$path"
15540 fi
15541
15542 if test "x$new_path" = x; then
15543 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15544 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15545 has_space=`$ECHO "$complete" | $GREP " "`
15546 if test "x$has_space" != x; then
15547 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15548 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15549 fi
15550 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15551 fi
15552 fi
15553
15554 # Now join together the path and the arguments once again
15555 if test "x$arguments" != xEOL; then
15556 new_complete="$new_path ${arguments% *}"
15557 else
15558 new_complete="$new_path"
15559 fi
15560
15561 if test "x$complete" != "x$new_complete"; then
15562 FOUND_MAKE="$new_complete"
15563 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15564 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15565 fi
15566
15567 fi
15568 fi
15569 fi
15570 fi
15571
15572
15573 if test "x$FOUND_MAKE" = x; then
15574 for ac_prog in make
15575 do
15576 # Extract the first word of "$ac_prog", so it can be a program name with args.
15577 set dummy $ac_prog; ac_word=$2
15578 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15579 $as_echo_n "checking for $ac_word... " >&6; }
15580 if ${ac_cv_path_CHECK_MAKE+:} false; then :
15581 $as_echo_n "(cached) " >&6
15582 else
15583 case $CHECK_MAKE in
15584 [\\/]* | ?:[\\/]*)
15585 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
15586 ;;
15587 *)
15588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15589 for as_dir in $PATH
15590 do
15591 IFS=$as_save_IFS
15592 test -z "$as_dir" && as_dir=.
15593 for ac_exec_ext in '' $ac_executable_extensions; do
15594 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15595 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
15596 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15597 break 2
15598 fi
15599 done
15600 done
15601 IFS=$as_save_IFS
15602
15603 ;;
15604 esac
15605 fi
15606 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
15607 if test -n "$CHECK_MAKE"; then
15608 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
15609 $as_echo "$CHECK_MAKE" >&6; }
15610 else
15611 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15612 $as_echo "no" >&6; }
15613 fi
15614
15615
15616 test -n "$CHECK_MAKE" && break
15617 done
15618
15619
15620 MAKE_CANDIDATE=""$CHECK_MAKE""
15621 DESCRIPTION="make in PATH"
15622 if test "x$MAKE_CANDIDATE" != x; then
15623 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15624 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15625 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15626 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15627 if test "x$IS_GNU_MAKE" = x; then
15628 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15629 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15630 else
15631 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15632 if test "x$IS_MODERN_MAKE" = x; then
15633 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15634 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15635 else
15636 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15637 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15638 MAKE_EXPECTED_ENV='cygwin'
15639 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15640 MAKE_EXPECTED_ENV='msys'
15641 else
15642 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15643 fi
15644 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15645 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15646 else
15647 # Not relevant for non-Windows
15648 IS_MAKE_CORRECT_ENV=true
15649 fi
15650 if test "x$IS_MAKE_CORRECT_ENV" = x; then
15651 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
15652 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
15653 else
15654 FOUND_MAKE=$MAKE_CANDIDATE
15655
15656 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15657
15658 # First separate the path from the arguments. This will split at the first
15659 # space.
15660 complete="$FOUND_MAKE"
15661 path="${complete%% *}"
15662 tmp="$complete EOL"
15663 arguments="${tmp#* }"
15664
15665 # Input might be given as Windows format, start by converting to
15666 # unix format.
15667 new_path=`$CYGPATH -u "$path"`
15668
15669 # Now try to locate executable using which
15670 new_path=`$WHICH "$new_path" 2> /dev/null`
15671 # bat and cmd files are not always considered executable in cygwin causing which
15672 # to not find them
15673 if test "x$new_path" = x \
15674 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15675 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15676 new_path=`$CYGPATH -u "$path"`
15677 fi
15678 if test "x$new_path" = x; then
15679 # Oops. Which didn't find the executable.
15680 # The splitting of arguments from the executable at a space might have been incorrect,
15681 # since paths with space are more likely in Windows. Give it another try with the whole
15682 # argument.
15683 path="$complete"
15684 arguments="EOL"
15685 new_path=`$CYGPATH -u "$path"`
15686 new_path=`$WHICH "$new_path" 2> /dev/null`
15687 # bat and cmd files are not always considered executable in cygwin causing which
15688 # to not find them
15689 if test "x$new_path" = x \
15690 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15691 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15692 new_path=`$CYGPATH -u "$path"`
15693 fi
15694 if test "x$new_path" = x; then
15695 # It's still not found. Now this is an unrecoverable error.
15696 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15697 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15698 has_space=`$ECHO "$complete" | $GREP " "`
15699 if test "x$has_space" != x; then
15700 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15701 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15702 fi
15703 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15704 fi
15705 fi
15706
15707 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15708 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15709 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15710 # "foo.exe" is OK but "foo" is an error.
15711 #
15712 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15713 # It is also a way to make sure we got the proper file name for the real test later on.
15714 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15715 if test "x$test_shortpath" = x; then
15716 # Short path failed, file does not exist as specified.
15717 # Try adding .exe or .cmd
15718 if test -f "${new_path}.exe"; then
15719 input_to_shortpath="${new_path}.exe"
15720 elif test -f "${new_path}.cmd"; then
15721 input_to_shortpath="${new_path}.cmd"
15722 else
15723 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15724 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15725 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15726 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15727 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15728 fi
15729 else
15730 input_to_shortpath="$new_path"
15731 fi
15732
15733 # Call helper function which possibly converts this using DOS-style short mode.
15734 # If so, the updated path is stored in $new_path.
15735 new_path="$input_to_shortpath"
15736
15737 input_path="$input_to_shortpath"
15738 # Check if we need to convert this using DOS-style short mode. If the path
15739 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15740 # take no chances and rewrite it.
15741 # Note: m4 eats our [], so we need to use [ and ] instead.
15742 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15743 if test "x$has_forbidden_chars" != x; then
15744 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15745 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15746 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15747 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15748 # Going to short mode and back again did indeed matter. Since short mode is
15749 # case insensitive, let's make it lowercase to improve readability.
15750 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15751 # Now convert it back to Unix-stile (cygpath)
15752 input_path=`$CYGPATH -u "$shortmode_path"`
15753 new_path="$input_path"
15754 fi
15755 fi
15756
15757 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15758 if test "x$test_cygdrive_prefix" = x; then
15759 # As a simple fix, exclude /usr/bin since it's not a real path.
15760 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15761 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15762 # a path prefixed by /cygdrive for fixpath to work.
15763 new_path="$CYGWIN_ROOT_PATH$input_path"
15764 fi
15765 fi
15766
15767 # remove trailing .exe if any
15768 new_path="${new_path/%.exe/}"
15769
15770 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15771
15772 # First separate the path from the arguments. This will split at the first
15773 # space.
15774 complete="$FOUND_MAKE"
15775 path="${complete%% *}"
15776 tmp="$complete EOL"
15777 arguments="${tmp#* }"
15778
15779 # Input might be given as Windows format, start by converting to
15780 # unix format.
15781 new_path="$path"
15782
15783 windows_path="$new_path"
15784 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15785 unix_path=`$CYGPATH -u "$windows_path"`
15786 new_path="$unix_path"
15787 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15788 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15789 new_path="$unix_path"
15790 fi
15791
15792
15793 # Now try to locate executable using which
15794 new_path=`$WHICH "$new_path" 2> /dev/null`
15795
15796 if test "x$new_path" = x; then
15797 # Oops. Which didn't find the executable.
15798 # The splitting of arguments from the executable at a space might have been incorrect,
15799 # since paths with space are more likely in Windows. Give it another try with the whole
15800 # argument.
15801 path="$complete"
15802 arguments="EOL"
15803 new_path="$path"
15804
15805 windows_path="$new_path"
15806 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15807 unix_path=`$CYGPATH -u "$windows_path"`
15808 new_path="$unix_path"
15809 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15810 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15811 new_path="$unix_path"
15812 fi
15813
15814
15815 new_path=`$WHICH "$new_path" 2> /dev/null`
15816
15817 if test "x$new_path" = x; then
15818 # It's still not found. Now this is an unrecoverable error.
15819 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15820 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15821 has_space=`$ECHO "$complete" | $GREP " "`
15822 if test "x$has_space" != x; then
15823 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15824 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15825 fi
15826 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15827 fi
15828 fi
15829
15830 # Now new_path has a complete unix path to the binary
15831 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15832 # Keep paths in /bin as-is, but remove trailing .exe if any
15833 new_path="${new_path/%.exe/}"
15834 # Do not save /bin paths to all_fixpath_prefixes!
15835 else
15836 # Not in mixed or Windows style, start by that.
15837 new_path=`cmd //c echo $new_path`
15838
15839 input_path="$new_path"
15840 # Check if we need to convert this using DOS-style short mode. If the path
15841 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15842 # take no chances and rewrite it.
15843 # Note: m4 eats our [], so we need to use [ and ] instead.
15844 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15845 if test "x$has_forbidden_chars" != x; then
15846 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15847 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15848 fi
15849
15850 # Output is in $new_path
15851
15852 windows_path="$new_path"
15853 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15854 unix_path=`$CYGPATH -u "$windows_path"`
15855 new_path="$unix_path"
15856 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15857 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15858 new_path="$unix_path"
15859 fi
15860
15861 # remove trailing .exe if any
15862 new_path="${new_path/%.exe/}"
15863
15864 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15865 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15866 fi
15867
15868 else
15869 # We're on a posix platform. Hooray! :)
15870 # First separate the path from the arguments. This will split at the first
15871 # space.
15872 complete="$FOUND_MAKE"
15873 path="${complete%% *}"
15874 tmp="$complete EOL"
15875 arguments="${tmp#* }"
15876
15877 # Cannot rely on the command "which" here since it doesn't always work.
15878 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15879 if test -z "$is_absolute_path"; then
15880 # Path to executable is not absolute. Find it.
15881 IFS_save="$IFS"
15882 IFS=:
15883 for p in $PATH; do
15884 if test -f "$p/$path" && test -x "$p/$path"; then
15885 new_path="$p/$path"
15886 break
15887 fi
15888 done
15889 IFS="$IFS_save"
15890 else
15891 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
15892 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
15893 new_path="$path"
15894 fi
15895
15896 if test "x$new_path" = x; then
15897 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15898 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15899 has_space=`$ECHO "$complete" | $GREP " "`
15900 if test "x$has_space" != x; then
15901 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15902 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15903 fi
15904 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15905 fi
15906 fi
15907
15908 # Now join together the path and the arguments once again
15909 if test "x$arguments" != xEOL; then
15910 new_complete="$new_path ${arguments% *}"
15911 else
15912 new_complete="$new_path"
15913 fi
15914
15915 if test "x$complete" != "x$new_complete"; then
15916 FOUND_MAKE="$new_complete"
15917 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15918 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15919 fi
15920
15921 fi
15922 fi
15923 fi
15924 fi
15925
15926 fi
15927
15928 if test "x$FOUND_MAKE" = x; then
15929 if test "x$TOOLS_DIR" != x; then
15930 # We have a tools-dir, check that as well before giving up.
15931 OLD_PATH=$PATH
15932 PATH=$TOOLS_DIR:$PATH
15933 for ac_prog in gmake
15934 do
15935 # Extract the first word of "$ac_prog", so it can be a program name with args.
15936 set dummy $ac_prog; ac_word=$2
15937 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15938 $as_echo_n "checking for $ac_word... " >&6; }
15939 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
15940 $as_echo_n "(cached) " >&6
15941 else
15942 case $CHECK_TOOLSDIR_GMAKE in
15943 [\\/]* | ?:[\\/]*)
15944 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
15945 ;;
15946 *)
15947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15948 for as_dir in $PATH
15949 do
15950 IFS=$as_save_IFS
15951 test -z "$as_dir" && as_dir=.
15952 for ac_exec_ext in '' $ac_executable_extensions; do
15953 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15954 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15955 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15956 break 2
15957 fi
15958 done
15959 done
15960 IFS=$as_save_IFS
15961
15962 ;;
15963 esac
15964 fi
15965 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
15966 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
15967 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
15968 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
15969 else
15970 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15971 $as_echo "no" >&6; }
15972 fi
15973
15974
15975 test -n "$CHECK_TOOLSDIR_GMAKE" && break
15976 done
15977
15978
15979 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
15980 DESCRIPTION="gmake in tools-dir"
15981 if test "x$MAKE_CANDIDATE" != x; then
15982 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15983 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15984 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15985 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15986 if test "x$IS_GNU_MAKE" = x; then
15987 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15988 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15989 else
15990 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15991 if test "x$IS_MODERN_MAKE" = x; then
15992 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15993 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15994 else
15995 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15996 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15997 MAKE_EXPECTED_ENV='cygwin'
15998 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15999 MAKE_EXPECTED_ENV='msys'
16000 else
16266
16267 # Now join together the path and the arguments once again
16268 if test "x$arguments" != xEOL; then
16269 new_complete="$new_path ${arguments% *}"
16270 else
16271 new_complete="$new_path"
16272 fi
16273
16274 if test "x$complete" != "x$new_complete"; then
16275 FOUND_MAKE="$new_complete"
16276 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16277 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16278 fi
16279
16280 fi
16281 fi
16282 fi
16283 fi
16284
16285 if test "x$FOUND_MAKE" = x; then
16286 for ac_prog in make
16287 do
16288 # Extract the first word of "$ac_prog", so it can be a program name with args.
16289 set dummy $ac_prog; ac_word=$2
16290 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16291 $as_echo_n "checking for $ac_word... " >&6; }
16292 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16293 $as_echo_n "(cached) " >&6
16294 else
16295 case $CHECK_TOOLSDIR_MAKE in
16296 [\\/]* | ?:[\\/]*)
16297 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16298 ;;
16299 *)
16300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16301 for as_dir in $PATH
16302 do
16303 IFS=$as_save_IFS
16304 test -z "$as_dir" && as_dir=.
16305 for ac_exec_ext in '' $ac_executable_extensions; do
16306 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16307 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16308 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16309 break 2
16310 fi
16311 done
16312 done
16313 IFS=$as_save_IFS
16314
16315 ;;
16316 esac
16317 fi
16318 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16319 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16320 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16321 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16322 else
16323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16324 $as_echo "no" >&6; }
16325 fi
16326
16327
16328 test -n "$CHECK_TOOLSDIR_MAKE" && break
16329 done
16330
16331
16332 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16333 DESCRIPTION="make in tools-dir"
16334 if test "x$MAKE_CANDIDATE" != x; then
16335 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16336 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16337 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16338 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16339 if test "x$IS_GNU_MAKE" = x; then
16340 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16341 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16342 else
16343 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16344 if test "x$IS_MODERN_MAKE" = x; then
16345 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16346 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16347 else
16348 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16349 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16350 MAKE_EXPECTED_ENV='cygwin'
16351 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16352 MAKE_EXPECTED_ENV='msys'
16353 else
16618 fi
16619
16620 # Now join together the path and the arguments once again
16621 if test "x$arguments" != xEOL; then
16622 new_complete="$new_path ${arguments% *}"
16623 else
16624 new_complete="$new_path"
16625 fi
16626
16627 if test "x$complete" != "x$new_complete"; then
16628 FOUND_MAKE="$new_complete"
16629 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16630 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16631 fi
16632
16633 fi
16634 fi
16635 fi
16636 fi
16637
16638 fi
16639 PATH=$OLD_PATH
16640 fi
16641 fi
16642
16643 if test "x$FOUND_MAKE" = x; then
16644 as_fn_error $? "Cannot find GNU make 3.81 or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
16645 fi
16646 fi
16647
16648 MAKE=$FOUND_MAKE
16649
16650 { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
16651 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
16652
16653
16654
16655 # Test if find supports -delete
16656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
16657 $as_echo_n "checking if find supports -delete... " >&6; }
16658 FIND_DELETE="-delete"
16659
16660 DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
16661
16662 echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
16663
16664 TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
16665 if test -f $DELETEDIR/TestIfFindSupportsDelete; then
16666 # No, it does not.
16667 rm $DELETEDIR/TestIfFindSupportsDelete
16668 FIND_DELETE="-exec rm \{\} \+"
16669 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16670 $as_echo "no" >&6; }
16671 else
16672 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
16673 $as_echo "yes" >&6; }
16674 fi
16675 rmdir $DELETEDIR
16676
16677
16678
16679 # These tools might not be installed by default,
16680 # need hint on how to install them.
16681
16682
16683
16684 # Publish this variable in the help.
16685
16686
16687 if test "x$UNZIP" = x; then
16688 # The variable is not set by user, try to locate tool using the code snippet
16689 for ac_prog in unzip
16690 do
16691 # Extract the first word of "$ac_prog", so it can be a program name with args.
16692 set dummy $ac_prog; ac_word=$2
16693 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16694 $as_echo_n "checking for $ac_word... " >&6; }
16695 if ${ac_cv_path_UNZIP+:} false; then :
16696 $as_echo_n "(cached) " >&6
16697 else
16698 case $UNZIP in
16699 [\\/]* | ?:[\\/]*)
16700 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16701 ;;
16702 *)
16703 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16704 for as_dir in $PATH
16705 do
16706 IFS=$as_save_IFS
16707 test -z "$as_dir" && as_dir=.
16708 for ac_exec_ext in '' $ac_executable_extensions; do
16709 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16710 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16711 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16712 break 2
16713 fi
16714 done
16715 done
16716 IFS=$as_save_IFS
16717
16718 ;;
16719 esac
16720 fi
16721 UNZIP=$ac_cv_path_UNZIP
16722 if test -n "$UNZIP"; then
16723 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16724 $as_echo "$UNZIP" >&6; }
16725 else
16726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16727 $as_echo "no" >&6; }
16728 fi
16729
16730
16731 test -n "$UNZIP" && break
16732 done
16733
16734 else
16735 # The variable is set, but is it from the command line or the environment?
16736
16737 # Try to remove the string !UNZIP! from our list.
16738 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
16739 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
16740 # If it failed, the variable was not from the command line. Ignore it,
16741 # but warn the user (except for BASH, which is always set by the calling BASH).
16742 if test "xUNZIP" != xBASH; then
16743 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
16744 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
16745 fi
16746 # Try to locate tool using the code snippet
16747 for ac_prog in unzip
16748 do
16749 # Extract the first word of "$ac_prog", so it can be a program name with args.
16750 set dummy $ac_prog; ac_word=$2
16751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16752 $as_echo_n "checking for $ac_word... " >&6; }
16753 if ${ac_cv_path_UNZIP+:} false; then :
16754 $as_echo_n "(cached) " >&6
16755 else
16756 case $UNZIP in
16757 [\\/]* | ?:[\\/]*)
16758 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16759 ;;
16760 *)
16761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16762 for as_dir in $PATH
16763 do
16764 IFS=$as_save_IFS
16765 test -z "$as_dir" && as_dir=.
16766 for ac_exec_ext in '' $ac_executable_extensions; do
16767 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16768 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16769 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16770 break 2
16771 fi
16772 done
16773 done
16774 IFS=$as_save_IFS
16775
16776 ;;
16777 esac
16778 fi
16779 UNZIP=$ac_cv_path_UNZIP
16780 if test -n "$UNZIP"; then
16781 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16782 $as_echo "$UNZIP" >&6; }
16783 else
16784 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16785 $as_echo "no" >&6; }
16786 fi
16787
16788
16789 test -n "$UNZIP" && break
16790 done
16791
16792 else
16793 # If it succeeded, then it was overridden by the user. We will use it
16794 # for the tool.
16795
16796 # First remove it from the list of overridden variables, so we can test
16797 # for unknown variables in the end.
16798 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
16799
16800 # Check if the provided tool contains a complete path.
16801 tool_specified="$UNZIP"
16802 tool_basename="${tool_specified##*/}"
16803 if test "x$tool_basename" = "x$tool_specified"; then
16804 # A command without a complete path is provided, search $PATH.
16805 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
16806 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
16807 # Extract the first word of "$tool_basename", so it can be a program name with args.
16808 set dummy $tool_basename; ac_word=$2
16809 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16810 $as_echo_n "checking for $ac_word... " >&6; }
16811 if ${ac_cv_path_UNZIP+:} false; then :
16812 $as_echo_n "(cached) " >&6
16813 else
16814 case $UNZIP in
16815 [\\/]* | ?:[\\/]*)
16816 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16817 ;;
16818 *)
16819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16820 for as_dir in $PATH
16821 do
16822 IFS=$as_save_IFS
16823 test -z "$as_dir" && as_dir=.
16824 for ac_exec_ext in '' $ac_executable_extensions; do
16825 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16826 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16827 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16828 break 2
16829 fi
16830 done
16831 done
16832 IFS=$as_save_IFS
16833
16834 ;;
16835 esac
16836 fi
16837 UNZIP=$ac_cv_path_UNZIP
16838 if test -n "$UNZIP"; then
16839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16840 $as_echo "$UNZIP" >&6; }
16841 else
16842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16843 $as_echo "no" >&6; }
16844 fi
16845
16846
16847 if test "x$UNZIP" = x; then
16848 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
16849 fi
16850 else
16851 # Otherwise we believe it is a complete path. Use it as it is.
16852 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
16853 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
16854 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
16855 $as_echo_n "checking for UNZIP... " >&6; }
16856 if test ! -x "$tool_specified"; then
16857 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
16858 $as_echo "not found" >&6; }
16859 as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
16860 fi
16861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
16862 $as_echo "$tool_specified" >&6; }
16863 fi
16864 fi
16865 fi
16866
16867
16868
16869 if test "x$UNZIP" = x; then
16870 as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
16871 fi
16872
16873
16874
16875
16876
16877 # Publish this variable in the help.
16878
16879
16880 if test "x$ZIP" = x; then
16881 # The variable is not set by user, try to locate tool using the code snippet
16882 for ac_prog in zip
16883 do
16884 # Extract the first word of "$ac_prog", so it can be a program name with args.
16885 set dummy $ac_prog; ac_word=$2
16886 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16887 $as_echo_n "checking for $ac_word... " >&6; }
16888 if ${ac_cv_path_ZIP+:} false; then :
16889 $as_echo_n "(cached) " >&6
16890 else
16891 case $ZIP in
16892 [\\/]* | ?:[\\/]*)
16893 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
16894 ;;
16895 *)
16896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16897 for as_dir in $PATH
16898 do
16899 IFS=$as_save_IFS
16900 test -z "$as_dir" && as_dir=.
16901 for ac_exec_ext in '' $ac_executable_extensions; do
16902 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16903 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
16904 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16905 break 2
16906 fi
16907 done
16908 done
16909 IFS=$as_save_IFS
16910
16911 ;;
16912 esac
16913 fi
16914 ZIP=$ac_cv_path_ZIP
16915 if test -n "$ZIP"; then
16916 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
16917 $as_echo "$ZIP" >&6; }
16918 else
16919 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16920 $as_echo "no" >&6; }
16921 fi
16922
16923
16924 test -n "$ZIP" && break
16925 done
16926
16927 else
16928 # The variable is set, but is it from the command line or the environment?
16929
16930 # Try to remove the string !ZIP! from our list.
16931 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
16932 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
16933 # If it failed, the variable was not from the command line. Ignore it,
16934 # but warn the user (except for BASH, which is always set by the calling BASH).
16935 if test "xZIP" != xBASH; then
16936 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
16937 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
16938 fi
16939 # Try to locate tool using the code snippet
16940 for ac_prog in zip
16941 do
16942 # Extract the first word of "$ac_prog", so it can be a program name with args.
16943 set dummy $ac_prog; ac_word=$2
16944 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16945 $as_echo_n "checking for $ac_word... " >&6; }
16946 if ${ac_cv_path_ZIP+:} false; then :
16947 $as_echo_n "(cached) " >&6
16948 else
16949 case $ZIP in
16950 [\\/]* | ?:[\\/]*)
16951 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
16952 ;;
16953 *)
16954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16955 for as_dir in $PATH
16956 do
16957 IFS=$as_save_IFS
16958 test -z "$as_dir" && as_dir=.
16959 for ac_exec_ext in '' $ac_executable_extensions; do
16960 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16961 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
16962 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16963 break 2
16964 fi
16965 done
16966 done
16967 IFS=$as_save_IFS
16968
16969 ;;
16970 esac
16971 fi
16972 ZIP=$ac_cv_path_ZIP
16973 if test -n "$ZIP"; then
16974 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
16975 $as_echo "$ZIP" >&6; }
16976 else
16977 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16978 $as_echo "no" >&6; }
16979 fi
16980
16981
16982 test -n "$ZIP" && break
16983 done
16984
16985 else
16986 # If it succeeded, then it was overridden by the user. We will use it
16987 # for the tool.
16988
16989 # First remove it from the list of overridden variables, so we can test
16990 # for unknown variables in the end.
16991 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
16992
16993 # Check if the provided tool contains a complete path.
16994 tool_specified="$ZIP"
16995 tool_basename="${tool_specified##*/}"
16996 if test "x$tool_basename" = "x$tool_specified"; then
16997 # A command without a complete path is provided, search $PATH.
16998 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
16999 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17000 # Extract the first word of "$tool_basename", so it can be a program name with args.
17001 set dummy $tool_basename; ac_word=$2
17002 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17003 $as_echo_n "checking for $ac_word... " >&6; }
17004 if ${ac_cv_path_ZIP+:} false; then :
17005 $as_echo_n "(cached) " >&6
17006 else
17007 case $ZIP in
17008 [\\/]* | ?:[\\/]*)
17009 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17010 ;;
17011 *)
17012 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17013 for as_dir in $PATH
17014 do
17015 IFS=$as_save_IFS
17016 test -z "$as_dir" && as_dir=.
17017 for ac_exec_ext in '' $ac_executable_extensions; do
17018 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17019 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17020 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17021 break 2
17022 fi
17023 done
17024 done
17025 IFS=$as_save_IFS
17026
17027 ;;
17028 esac
17029 fi
17030 ZIP=$ac_cv_path_ZIP
17031 if test -n "$ZIP"; then
17032 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17033 $as_echo "$ZIP" >&6; }
17034 else
17035 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17036 $as_echo "no" >&6; }
17037 fi
17038
17039
17040 if test "x$ZIP" = x; then
17041 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17042 fi
17043 else
17044 # Otherwise we believe it is a complete path. Use it as it is.
17045 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17046 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17048 $as_echo_n "checking for ZIP... " >&6; }
17049 if test ! -x "$tool_specified"; then
17050 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17051 $as_echo "not found" >&6; }
17052 as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17053 fi
17054 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17055 $as_echo "$tool_specified" >&6; }
17056 fi
17057 fi
17058 fi
17059
17060
17061
17062 if test "x$ZIP" = x; then
17063 as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17064 fi
17065
17066
17067
17068 # Non-required basic tools
17069
17070
17071
17072 # Publish this variable in the help.
17073
17074
17075 if test "x$LDD" = x; then
17076 # The variable is not set by user, try to locate tool using the code snippet
17077 for ac_prog in ldd
17078 do
17079 # Extract the first word of "$ac_prog", so it can be a program name with args.
17080 set dummy $ac_prog; ac_word=$2
17081 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17082 $as_echo_n "checking for $ac_word... " >&6; }
17083 if ${ac_cv_path_LDD+:} false; then :
17084 $as_echo_n "(cached) " >&6
17085 else
17086 case $LDD in
17087 [\\/]* | ?:[\\/]*)
17088 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17089 ;;
17090 *)
17091 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17092 for as_dir in $PATH
17093 do
17094 IFS=$as_save_IFS
17095 test -z "$as_dir" && as_dir=.
17096 for ac_exec_ext in '' $ac_executable_extensions; do
17097 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17098 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17099 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17100 break 2
17101 fi
17102 done
17103 done
17104 IFS=$as_save_IFS
17105
17106 ;;
17107 esac
17108 fi
17109 LDD=$ac_cv_path_LDD
17110 if test -n "$LDD"; then
17111 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17112 $as_echo "$LDD" >&6; }
17113 else
17114 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17115 $as_echo "no" >&6; }
17116 fi
17117
17118
17119 test -n "$LDD" && break
17120 done
17121
17122 else
17123 # The variable is set, but is it from the command line or the environment?
17124
17125 # Try to remove the string !LDD! from our list.
17126 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17127 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17128 # If it failed, the variable was not from the command line. Ignore it,
17129 # but warn the user (except for BASH, which is always set by the calling BASH).
17130 if test "xLDD" != xBASH; then
17131 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17132 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17133 fi
17134 # Try to locate tool using the code snippet
17135 for ac_prog in ldd
17136 do
17137 # Extract the first word of "$ac_prog", so it can be a program name with args.
17138 set dummy $ac_prog; ac_word=$2
17139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17140 $as_echo_n "checking for $ac_word... " >&6; }
17141 if ${ac_cv_path_LDD+:} false; then :
17142 $as_echo_n "(cached) " >&6
17143 else
17144 case $LDD in
17145 [\\/]* | ?:[\\/]*)
17146 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17147 ;;
17148 *)
17149 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17150 for as_dir in $PATH
17151 do
17152 IFS=$as_save_IFS
17153 test -z "$as_dir" && as_dir=.
17154 for ac_exec_ext in '' $ac_executable_extensions; do
17155 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17156 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17157 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17158 break 2
17159 fi
17160 done
17161 done
17162 IFS=$as_save_IFS
17163
17164 ;;
17165 esac
17166 fi
17167 LDD=$ac_cv_path_LDD
17168 if test -n "$LDD"; then
17169 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17170 $as_echo "$LDD" >&6; }
17171 else
17172 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17173 $as_echo "no" >&6; }
17174 fi
17175
17176
17177 test -n "$LDD" && break
17178 done
17179
17180 else
17181 # If it succeeded, then it was overridden by the user. We will use it
17182 # for the tool.
17183
17184 # First remove it from the list of overridden variables, so we can test
17185 # for unknown variables in the end.
17186 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17187
17188 # Check if the provided tool contains a complete path.
17189 tool_specified="$LDD"
17190 tool_basename="${tool_specified##*/}"
17191 if test "x$tool_basename" = "x$tool_specified"; then
17192 # A command without a complete path is provided, search $PATH.
17193 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17194 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17195 # Extract the first word of "$tool_basename", so it can be a program name with args.
17196 set dummy $tool_basename; ac_word=$2
17197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17198 $as_echo_n "checking for $ac_word... " >&6; }
17199 if ${ac_cv_path_LDD+:} false; then :
17200 $as_echo_n "(cached) " >&6
17201 else
17202 case $LDD in
17203 [\\/]* | ?:[\\/]*)
17204 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17205 ;;
17206 *)
17207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17208 for as_dir in $PATH
17209 do
17210 IFS=$as_save_IFS
17211 test -z "$as_dir" && as_dir=.
17212 for ac_exec_ext in '' $ac_executable_extensions; do
17213 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17214 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17215 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17216 break 2
17217 fi
17218 done
17219 done
17220 IFS=$as_save_IFS
17221
17222 ;;
17223 esac
17224 fi
17225 LDD=$ac_cv_path_LDD
17226 if test -n "$LDD"; then
17227 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17228 $as_echo "$LDD" >&6; }
17229 else
17230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17231 $as_echo "no" >&6; }
17232 fi
17233
17234
17235 if test "x$LDD" = x; then
17236 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17237 fi
17238 else
17239 # Otherwise we believe it is a complete path. Use it as it is.
17240 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17241 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17242 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17243 $as_echo_n "checking for LDD... " >&6; }
17244 if test ! -x "$tool_specified"; then
17245 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17246 $as_echo "not found" >&6; }
17247 as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17248 fi
17249 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17250 $as_echo "$tool_specified" >&6; }
17251 fi
17252 fi
17253 fi
17254
17255
17256 if test "x$LDD" = "x"; then
17257 # List shared lib dependencies is used for
17258 # debug output and checking for forbidden dependencies.
17259 # We can build without it.
17260 LDD="true"
17261 fi
17262
17263
17264 # Publish this variable in the help.
17265
17266
17267 if test "x$READELF" = x; then
17268 # The variable is not set by user, try to locate tool using the code snippet
17269 for ac_prog in readelf greadelf
17270 do
17271 # Extract the first word of "$ac_prog", so it can be a program name with args.
17272 set dummy $ac_prog; ac_word=$2
17273 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17274 $as_echo_n "checking for $ac_word... " >&6; }
17275 if ${ac_cv_path_READELF+:} false; then :
17276 $as_echo_n "(cached) " >&6
17277 else
17278 case $READELF in
17279 [\\/]* | ?:[\\/]*)
17280 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17281 ;;
17282 *)
17283 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17284 for as_dir in $PATH
17285 do
17286 IFS=$as_save_IFS
17287 test -z "$as_dir" && as_dir=.
17288 for ac_exec_ext in '' $ac_executable_extensions; do
17289 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17290 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17291 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17292 break 2
17293 fi
17294 done
17295 done
17296 IFS=$as_save_IFS
17297
17298 ;;
17299 esac
17300 fi
17301 READELF=$ac_cv_path_READELF
17302 if test -n "$READELF"; then
17303 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17304 $as_echo "$READELF" >&6; }
17305 else
17306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17307 $as_echo "no" >&6; }
17308 fi
17309
17310
17311 test -n "$READELF" && break
17312 done
17313
17314 else
17315 # The variable is set, but is it from the command line or the environment?
17316
17317 # Try to remove the string !READELF! from our list.
17318 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
17319 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17320 # If it failed, the variable was not from the command line. Ignore it,
17321 # but warn the user (except for BASH, which is always set by the calling BASH).
17322 if test "xREADELF" != xBASH; then
17323 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
17324 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
17325 fi
17326 # Try to locate tool using the code snippet
17327 for ac_prog in readelf greadelf
17328 do
17329 # Extract the first word of "$ac_prog", so it can be a program name with args.
17330 set dummy $ac_prog; ac_word=$2
17331 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17332 $as_echo_n "checking for $ac_word... " >&6; }
17333 if ${ac_cv_path_READELF+:} false; then :
17334 $as_echo_n "(cached) " >&6
17335 else
17336 case $READELF in
17337 [\\/]* | ?:[\\/]*)
17338 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17339 ;;
17340 *)
17341 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17342 for as_dir in $PATH
17343 do
17344 IFS=$as_save_IFS
17345 test -z "$as_dir" && as_dir=.
17346 for ac_exec_ext in '' $ac_executable_extensions; do
17347 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17348 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17349 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17350 break 2
17351 fi
17352 done
17353 done
17354 IFS=$as_save_IFS
17355
17356 ;;
17357 esac
17358 fi
17359 READELF=$ac_cv_path_READELF
17360 if test -n "$READELF"; then
17361 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17362 $as_echo "$READELF" >&6; }
17363 else
17364 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17365 $as_echo "no" >&6; }
17366 fi
17367
17368
17369 test -n "$READELF" && break
17370 done
17371
17372 else
17373 # If it succeeded, then it was overridden by the user. We will use it
17374 # for the tool.
17375
17376 # First remove it from the list of overridden variables, so we can test
17377 # for unknown variables in the end.
17378 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17379
17380 # Check if the provided tool contains a complete path.
17381 tool_specified="$READELF"
17382 tool_basename="${tool_specified##*/}"
17383 if test "x$tool_basename" = "x$tool_specified"; then
17384 # A command without a complete path is provided, search $PATH.
17385 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
17386 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
17387 # Extract the first word of "$tool_basename", so it can be a program name with args.
17388 set dummy $tool_basename; ac_word=$2
17389 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17390 $as_echo_n "checking for $ac_word... " >&6; }
17391 if ${ac_cv_path_READELF+:} false; then :
17392 $as_echo_n "(cached) " >&6
17393 else
17394 case $READELF in
17395 [\\/]* | ?:[\\/]*)
17396 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17397 ;;
17398 *)
17399 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17400 for as_dir in $PATH
17401 do
17402 IFS=$as_save_IFS
17403 test -z "$as_dir" && as_dir=.
17404 for ac_exec_ext in '' $ac_executable_extensions; do
17405 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17406 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17407 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17408 break 2
17409 fi
17410 done
17411 done
17412 IFS=$as_save_IFS
17413
17414 ;;
17415 esac
17416 fi
17417 READELF=$ac_cv_path_READELF
17418 if test -n "$READELF"; then
17419 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17420 $as_echo "$READELF" >&6; }
17421 else
17422 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17423 $as_echo "no" >&6; }
17424 fi
17425
17426
17427 if test "x$READELF" = x; then
17428 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17429 fi
17430 else
17431 # Otherwise we believe it is a complete path. Use it as it is.
17432 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
17433 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
17434 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
17435 $as_echo_n "checking for READELF... " >&6; }
17436 if test ! -x "$tool_specified"; then
17437 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17438 $as_echo "not found" >&6; }
17439 as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
17440 fi
17441 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17442 $as_echo "$tool_specified" >&6; }
17443 fi
17444 fi
17445 fi
17446
17447
17448
17449
17450 # Publish this variable in the help.
17451
17452
17453 if test "x$HG" = x; then
17454 # The variable is not set by user, try to locate tool using the code snippet
17455 for ac_prog in hg
17456 do
17457 # Extract the first word of "$ac_prog", so it can be a program name with args.
17458 set dummy $ac_prog; ac_word=$2
17459 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17460 $as_echo_n "checking for $ac_word... " >&6; }
17461 if ${ac_cv_path_HG+:} false; then :
17462 $as_echo_n "(cached) " >&6
17463 else
17464 case $HG in
17465 [\\/]* | ?:[\\/]*)
17466 ac_cv_path_HG="$HG" # Let the user override the test with a path.
17467 ;;
17468 *)
17469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17470 for as_dir in $PATH
17471 do
17472 IFS=$as_save_IFS
17473 test -z "$as_dir" && as_dir=.
17474 for ac_exec_ext in '' $ac_executable_extensions; do
17475 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17476 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17477 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17478 break 2
17479 fi
17480 done
17481 done
17482 IFS=$as_save_IFS
17483
17484 ;;
17485 esac
17486 fi
17487 HG=$ac_cv_path_HG
17488 if test -n "$HG"; then
17489 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17490 $as_echo "$HG" >&6; }
17491 else
17492 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17493 $as_echo "no" >&6; }
17494 fi
17495
17496
17497 test -n "$HG" && break
17498 done
17499
17500 else
17501 # The variable is set, but is it from the command line or the environment?
17502
17503 # Try to remove the string !HG! from our list.
17504 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
17505 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17506 # If it failed, the variable was not from the command line. Ignore it,
17507 # but warn the user (except for BASH, which is always set by the calling BASH).
17508 if test "xHG" != xBASH; then
17509 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
17510 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
17511 fi
17512 # Try to locate tool using the code snippet
17513 for ac_prog in hg
17514 do
17515 # Extract the first word of "$ac_prog", so it can be a program name with args.
17516 set dummy $ac_prog; ac_word=$2
17517 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17518 $as_echo_n "checking for $ac_word... " >&6; }
17519 if ${ac_cv_path_HG+:} false; then :
17520 $as_echo_n "(cached) " >&6
17521 else
17522 case $HG in
17523 [\\/]* | ?:[\\/]*)
17524 ac_cv_path_HG="$HG" # Let the user override the test with a path.
17525 ;;
17526 *)
17527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17528 for as_dir in $PATH
17529 do
17530 IFS=$as_save_IFS
17531 test -z "$as_dir" && as_dir=.
17532 for ac_exec_ext in '' $ac_executable_extensions; do
17533 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17534 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17535 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17536 break 2
17537 fi
17538 done
17539 done
17540 IFS=$as_save_IFS
17541
17542 ;;
17543 esac
17544 fi
17545 HG=$ac_cv_path_HG
17546 if test -n "$HG"; then
17547 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17548 $as_echo "$HG" >&6; }
17549 else
17550 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17551 $as_echo "no" >&6; }
17552 fi
17553
17554
17555 test -n "$HG" && break
17556 done
17557
17558 else
17559 # If it succeeded, then it was overridden by the user. We will use it
17560 # for the tool.
17561
17562 # First remove it from the list of overridden variables, so we can test
17563 # for unknown variables in the end.
17564 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17565
17566 # Check if the provided tool contains a complete path.
17567 tool_specified="$HG"
17568 tool_basename="${tool_specified##*/}"
17569 if test "x$tool_basename" = "x$tool_specified"; then
17570 # A command without a complete path is provided, search $PATH.
17571 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
17572 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
17573 # Extract the first word of "$tool_basename", so it can be a program name with args.
17574 set dummy $tool_basename; ac_word=$2
17575 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17576 $as_echo_n "checking for $ac_word... " >&6; }
17577 if ${ac_cv_path_HG+:} false; then :
17578 $as_echo_n "(cached) " >&6
17579 else
17580 case $HG in
17581 [\\/]* | ?:[\\/]*)
17582 ac_cv_path_HG="$HG" # Let the user override the test with a path.
17583 ;;
17584 *)
17585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17586 for as_dir in $PATH
17587 do
17588 IFS=$as_save_IFS
17589 test -z "$as_dir" && as_dir=.
17590 for ac_exec_ext in '' $ac_executable_extensions; do
17591 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17592 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17593 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17594 break 2
17595 fi
17596 done
17597 done
17598 IFS=$as_save_IFS
17599
17600 ;;
17601 esac
17602 fi
17603 HG=$ac_cv_path_HG
17604 if test -n "$HG"; then
17605 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17606 $as_echo "$HG" >&6; }
17607 else
17608 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17609 $as_echo "no" >&6; }
17610 fi
17611
17612
17613 if test "x$HG" = x; then
17614 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17615 fi
17616 else
17617 # Otherwise we believe it is a complete path. Use it as it is.
17618 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
17619 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
17620 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
17621 $as_echo_n "checking for HG... " >&6; }
17622 if test ! -x "$tool_specified"; then
17623 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17624 $as_echo "not found" >&6; }
17625 as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
17626 fi
17627 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17628 $as_echo "$tool_specified" >&6; }
17629 fi
17630 fi
17631 fi
17632
17633
17634
17635
17636 # Publish this variable in the help.
17637
17638
17639 if test "x$STAT" = x; then
17640 # The variable is not set by user, try to locate tool using the code snippet
17641 for ac_prog in stat
17642 do
17643 # Extract the first word of "$ac_prog", so it can be a program name with args.
17644 set dummy $ac_prog; ac_word=$2
17645 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17646 $as_echo_n "checking for $ac_word... " >&6; }
17647 if ${ac_cv_path_STAT+:} false; then :
17648 $as_echo_n "(cached) " >&6
17649 else
17650 case $STAT in
17651 [\\/]* | ?:[\\/]*)
17652 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
17653 ;;
17654 *)
17655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17656 for as_dir in $PATH
17657 do
17658 IFS=$as_save_IFS
17659 test -z "$as_dir" && as_dir=.
17660 for ac_exec_ext in '' $ac_executable_extensions; do
17661 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17662 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
17663 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17664 break 2
17665 fi
17666 done
17667 done
17668 IFS=$as_save_IFS
17669
17670 ;;
17671 esac
17672 fi
17673 STAT=$ac_cv_path_STAT
17674 if test -n "$STAT"; then
17675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
17676 $as_echo "$STAT" >&6; }
17677 else
17678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17679 $as_echo "no" >&6; }
17680 fi
17681
17682
17683 test -n "$STAT" && break
17684 done
17685
17686 else
17687 # The variable is set, but is it from the command line or the environment?
17688
17689 # Try to remove the string !STAT! from our list.
17690 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
17691 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17692 # If it failed, the variable was not from the command line. Ignore it,
17693 # but warn the user (except for BASH, which is always set by the calling BASH).
17694 if test "xSTAT" != xBASH; then
17695 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
17696 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
17697 fi
17698 # Try to locate tool using the code snippet
17699 for ac_prog in stat
17700 do
17701 # Extract the first word of "$ac_prog", so it can be a program name with args.
17702 set dummy $ac_prog; ac_word=$2
17703 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17704 $as_echo_n "checking for $ac_word... " >&6; }
17705 if ${ac_cv_path_STAT+:} false; then :
17706 $as_echo_n "(cached) " >&6
17707 else
17708 case $STAT in
17709 [\\/]* | ?:[\\/]*)
17710 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
17711 ;;
17712 *)
17713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17714 for as_dir in $PATH
17715 do
17716 IFS=$as_save_IFS
17717 test -z "$as_dir" && as_dir=.
17718 for ac_exec_ext in '' $ac_executable_extensions; do
17719 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17720 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
17721 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17722 break 2
17723 fi
17724 done
17725 done
17726 IFS=$as_save_IFS
17727
17728 ;;
17729 esac
17730 fi
17731 STAT=$ac_cv_path_STAT
17732 if test -n "$STAT"; then
17733 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
17734 $as_echo "$STAT" >&6; }
17735 else
17736 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17737 $as_echo "no" >&6; }
17738 fi
17739
17740
17741 test -n "$STAT" && break
17742 done
17743
17744 else
17745 # If it succeeded, then it was overridden by the user. We will use it
17746 # for the tool.
17747
17748 # First remove it from the list of overridden variables, so we can test
17749 # for unknown variables in the end.
17750 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17751
17752 # Check if the provided tool contains a complete path.
17753 tool_specified="$STAT"
17754 tool_basename="${tool_specified##*/}"
17755 if test "x$tool_basename" = "x$tool_specified"; then
17756 # A command without a complete path is provided, search $PATH.
17757 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
17758 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
17759 # Extract the first word of "$tool_basename", so it can be a program name with args.
17760 set dummy $tool_basename; ac_word=$2
17761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17762 $as_echo_n "checking for $ac_word... " >&6; }
17763 if ${ac_cv_path_STAT+:} false; then :
17764 $as_echo_n "(cached) " >&6
17765 else
17766 case $STAT in
17767 [\\/]* | ?:[\\/]*)
17768 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
17769 ;;
17770 *)
17771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17772 for as_dir in $PATH
17773 do
17774 IFS=$as_save_IFS
17775 test -z "$as_dir" && as_dir=.
17776 for ac_exec_ext in '' $ac_executable_extensions; do
17777 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17778 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
17779 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17780 break 2
17781 fi
17782 done
17783 done
17784 IFS=$as_save_IFS
17785
17786 ;;
17787 esac
17788 fi
17789 STAT=$ac_cv_path_STAT
17790 if test -n "$STAT"; then
17791 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
17792 $as_echo "$STAT" >&6; }
17793 else
17794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17795 $as_echo "no" >&6; }
17796 fi
17797
17798
17799 if test "x$STAT" = x; then
17800 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17801 fi
17802 else
17803 # Otherwise we believe it is a complete path. Use it as it is.
17804 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
17805 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
17806 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
17807 $as_echo_n "checking for STAT... " >&6; }
17808 if test ! -x "$tool_specified"; then
17809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17810 $as_echo "not found" >&6; }
17811 as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
17812 fi
17813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17814 $as_echo "$tool_specified" >&6; }
17815 fi
17816 fi
17817 fi
17818
17819
17820
17821
17822 # Publish this variable in the help.
17823
17824
17825 if test "x$TIME" = x; then
17826 # The variable is not set by user, try to locate tool using the code snippet
17827 for ac_prog in time
17828 do
17829 # Extract the first word of "$ac_prog", so it can be a program name with args.
17830 set dummy $ac_prog; ac_word=$2
17831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17832 $as_echo_n "checking for $ac_word... " >&6; }
17833 if ${ac_cv_path_TIME+:} false; then :
17834 $as_echo_n "(cached) " >&6
17835 else
17836 case $TIME in
17837 [\\/]* | ?:[\\/]*)
17838 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
17839 ;;
17840 *)
17841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17842 for as_dir in $PATH
17843 do
17844 IFS=$as_save_IFS
17845 test -z "$as_dir" && as_dir=.
17846 for ac_exec_ext in '' $ac_executable_extensions; do
17847 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17848 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
17849 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17850 break 2
17851 fi
17852 done
17853 done
17854 IFS=$as_save_IFS
17855
17856 ;;
17857 esac
17858 fi
17859 TIME=$ac_cv_path_TIME
17860 if test -n "$TIME"; then
17861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
17862 $as_echo "$TIME" >&6; }
17863 else
17864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17865 $as_echo "no" >&6; }
17866 fi
17867
17868
17869 test -n "$TIME" && break
17870 done
17871
17872 else
17873 # The variable is set, but is it from the command line or the environment?
17874
17875 # Try to remove the string !TIME! from our list.
17876 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
17877 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17878 # If it failed, the variable was not from the command line. Ignore it,
17879 # but warn the user (except for BASH, which is always set by the calling BASH).
17880 if test "xTIME" != xBASH; then
17881 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
17882 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
17883 fi
17884 # Try to locate tool using the code snippet
17885 for ac_prog in time
17886 do
17887 # Extract the first word of "$ac_prog", so it can be a program name with args.
17888 set dummy $ac_prog; ac_word=$2
17889 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17890 $as_echo_n "checking for $ac_word... " >&6; }
17891 if ${ac_cv_path_TIME+:} false; then :
17892 $as_echo_n "(cached) " >&6
17893 else
17894 case $TIME in
17895 [\\/]* | ?:[\\/]*)
17896 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
17897 ;;
17898 *)
17899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17900 for as_dir in $PATH
17901 do
17902 IFS=$as_save_IFS
17903 test -z "$as_dir" && as_dir=.
17904 for ac_exec_ext in '' $ac_executable_extensions; do
17905 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17906 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
17907 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17908 break 2
17909 fi
17910 done
17911 done
17912 IFS=$as_save_IFS
17913
17914 ;;
17915 esac
17916 fi
17917 TIME=$ac_cv_path_TIME
17918 if test -n "$TIME"; then
17919 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
17920 $as_echo "$TIME" >&6; }
17921 else
17922 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17923 $as_echo "no" >&6; }
17924 fi
17925
17926
17927 test -n "$TIME" && break
17928 done
17929
17930 else
17931 # If it succeeded, then it was overridden by the user. We will use it
17932 # for the tool.
17933
17934 # First remove it from the list of overridden variables, so we can test
17935 # for unknown variables in the end.
17936 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17937
17938 # Check if the provided tool contains a complete path.
17939 tool_specified="$TIME"
17940 tool_basename="${tool_specified##*/}"
17941 if test "x$tool_basename" = "x$tool_specified"; then
17942 # A command without a complete path is provided, search $PATH.
17943 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
17944 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
17945 # Extract the first word of "$tool_basename", so it can be a program name with args.
17946 set dummy $tool_basename; ac_word=$2
17947 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17948 $as_echo_n "checking for $ac_word... " >&6; }
17949 if ${ac_cv_path_TIME+:} false; then :
17950 $as_echo_n "(cached) " >&6
17951 else
17952 case $TIME in
17953 [\\/]* | ?:[\\/]*)
17954 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
17955 ;;
17956 *)
17957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17958 for as_dir in $PATH
17959 do
17960 IFS=$as_save_IFS
17961 test -z "$as_dir" && as_dir=.
17962 for ac_exec_ext in '' $ac_executable_extensions; do
17963 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17964 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
17965 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17966 break 2
17967 fi
17968 done
17969 done
17970 IFS=$as_save_IFS
17971
17972 ;;
17973 esac
17974 fi
17975 TIME=$ac_cv_path_TIME
17976 if test -n "$TIME"; then
17977 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
17978 $as_echo "$TIME" >&6; }
17979 else
17980 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17981 $as_echo "no" >&6; }
17982 fi
17983
17984
17985 if test "x$TIME" = x; then
17986 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17987 fi
17988 else
17989 # Otherwise we believe it is a complete path. Use it as it is.
17990 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
17991 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
17992 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
17993 $as_echo_n "checking for TIME... " >&6; }
17994 if test ! -x "$tool_specified"; then
17995 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17996 $as_echo "not found" >&6; }
17997 as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
17998 fi
17999 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18000 $as_echo "$tool_specified" >&6; }
18001 fi
18002 fi
18003 fi
18004
18005
18006 # Check if it's GNU time
18007 IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18008 if test "x$IS_GNU_TIME" != x; then
18009 IS_GNU_TIME=yes
18010 else
18011 IS_GNU_TIME=no
18012 fi
18013
18014
18015 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
18016
18017
18018
18019 # Publish this variable in the help.
18020
18021
18022 if test "x$COMM" = x; then
18023 # The variable is not set by user, try to locate tool using the code snippet
18024 for ac_prog in comm
18025 do
18026 # Extract the first word of "$ac_prog", so it can be a program name with args.
18027 set dummy $ac_prog; ac_word=$2
18028 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18029 $as_echo_n "checking for $ac_word... " >&6; }
18030 if ${ac_cv_path_COMM+:} false; then :
18031 $as_echo_n "(cached) " >&6
18032 else
18033 case $COMM in
18034 [\\/]* | ?:[\\/]*)
18035 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18036 ;;
18037 *)
18038 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18039 for as_dir in $PATH
18040 do
18041 IFS=$as_save_IFS
18042 test -z "$as_dir" && as_dir=.
18043 for ac_exec_ext in '' $ac_executable_extensions; do
18044 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18045 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18046 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18047 break 2
18048 fi
18049 done
18050 done
18051 IFS=$as_save_IFS
18052
18053 ;;
18054 esac
18055 fi
18056 COMM=$ac_cv_path_COMM
18057 if test -n "$COMM"; then
18058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18059 $as_echo "$COMM" >&6; }
18060 else
18061 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18062 $as_echo "no" >&6; }
18063 fi
18064
18065
18066 test -n "$COMM" && break
18067 done
18068
18069 else
18070 # The variable is set, but is it from the command line or the environment?
18071
18072 # Try to remove the string !COMM! from our list.
18073 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
18074 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18075 # If it failed, the variable was not from the command line. Ignore it,
18076 # but warn the user (except for BASH, which is always set by the calling BASH).
18077 if test "xCOMM" != xBASH; then
18078 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
18079 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
18080 fi
18081 # Try to locate tool using the code snippet
18082 for ac_prog in comm
18083 do
18084 # Extract the first word of "$ac_prog", so it can be a program name with args.
18085 set dummy $ac_prog; ac_word=$2
18086 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18087 $as_echo_n "checking for $ac_word... " >&6; }
18088 if ${ac_cv_path_COMM+:} false; then :
18089 $as_echo_n "(cached) " >&6
18090 else
18091 case $COMM in
18092 [\\/]* | ?:[\\/]*)
18093 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18094 ;;
18095 *)
18096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18097 for as_dir in $PATH
18098 do
18099 IFS=$as_save_IFS
18100 test -z "$as_dir" && as_dir=.
18101 for ac_exec_ext in '' $ac_executable_extensions; do
18102 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18103 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18104 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18105 break 2
18106 fi
18107 done
18108 done
18109 IFS=$as_save_IFS
18110
18111 ;;
18112 esac
18113 fi
18114 COMM=$ac_cv_path_COMM
18115 if test -n "$COMM"; then
18116 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18117 $as_echo "$COMM" >&6; }
18118 else
18119 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18120 $as_echo "no" >&6; }
18121 fi
18122
18123
18124 test -n "$COMM" && break
18125 done
18126
18127 else
18128 # If it succeeded, then it was overridden by the user. We will use it
18129 # for the tool.
18130
18131 # First remove it from the list of overridden variables, so we can test
18132 # for unknown variables in the end.
18133 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18134
18135 # Check if the provided tool contains a complete path.
18136 tool_specified="$COMM"
18137 tool_basename="${tool_specified##*/}"
18138 if test "x$tool_basename" = "x$tool_specified"; then
18139 # A command without a complete path is provided, search $PATH.
18140 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
18141 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
18142 # Extract the first word of "$tool_basename", so it can be a program name with args.
18143 set dummy $tool_basename; ac_word=$2
18144 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18145 $as_echo_n "checking for $ac_word... " >&6; }
18146 if ${ac_cv_path_COMM+:} false; then :
18147 $as_echo_n "(cached) " >&6
18148 else
18149 case $COMM in
18150 [\\/]* | ?:[\\/]*)
18151 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18152 ;;
18153 *)
18154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18155 for as_dir in $PATH
18156 do
18157 IFS=$as_save_IFS
18158 test -z "$as_dir" && as_dir=.
18159 for ac_exec_ext in '' $ac_executable_extensions; do
18160 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18161 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18162 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18163 break 2
18164 fi
18165 done
18166 done
18167 IFS=$as_save_IFS
18168
18169 ;;
18170 esac
18171 fi
18172 COMM=$ac_cv_path_COMM
18173 if test -n "$COMM"; then
18174 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18175 $as_echo "$COMM" >&6; }
18176 else
18177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18178 $as_echo "no" >&6; }
18179 fi
18180
18181
18182 if test "x$COMM" = x; then
18183 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18184 fi
18185 else
18186 # Otherwise we believe it is a complete path. Use it as it is.
18187 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
18188 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
18189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
18190 $as_echo_n "checking for COMM... " >&6; }
18191 if test ! -x "$tool_specified"; then
18192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18193 $as_echo "not found" >&6; }
18194 as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
18195 fi
18196 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18197 $as_echo "$tool_specified" >&6; }
18198 fi
18199 fi
18200 fi
18201
18202
18203
18204 if test "x$COMM" = x; then
18205 as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
18206 fi
18207
18208
18209 fi
18210
18211 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18212
18213
18214
18215 # Publish this variable in the help.
18216
18217
18218 if test "x$DSYMUTIL" = x; then
18219 # The variable is not set by user, try to locate tool using the code snippet
18220 for ac_prog in dsymutil
18221 do
18222 # Extract the first word of "$ac_prog", so it can be a program name with args.
18223 set dummy $ac_prog; ac_word=$2
18224 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18225 $as_echo_n "checking for $ac_word... " >&6; }
18226 if ${ac_cv_path_DSYMUTIL+:} false; then :
18227 $as_echo_n "(cached) " >&6
18228 else
18229 case $DSYMUTIL in
18230 [\\/]* | ?:[\\/]*)
18231 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18232 ;;
18233 *)
18234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18235 for as_dir in $PATH
18236 do
18237 IFS=$as_save_IFS
18238 test -z "$as_dir" && as_dir=.
18239 for ac_exec_ext in '' $ac_executable_extensions; do
18240 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18241 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18242 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18243 break 2
18244 fi
18245 done
18246 done
18247 IFS=$as_save_IFS
18248
18249 ;;
18250 esac
18251 fi
18252 DSYMUTIL=$ac_cv_path_DSYMUTIL
18253 if test -n "$DSYMUTIL"; then
18254 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18255 $as_echo "$DSYMUTIL" >&6; }
18256 else
18257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18258 $as_echo "no" >&6; }
18259 fi
18260
18261
18262 test -n "$DSYMUTIL" && break
18263 done
18264
18265 else
18266 # The variable is set, but is it from the command line or the environment?
18267
18268 # Try to remove the string !DSYMUTIL! from our list.
18269 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18270 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18271 # If it failed, the variable was not from the command line. Ignore it,
18272 # but warn the user (except for BASH, which is always set by the calling BASH).
18273 if test "xDSYMUTIL" != xBASH; then
18274 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18275 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18276 fi
18277 # Try to locate tool using the code snippet
18278 for ac_prog in dsymutil
18279 do
18280 # Extract the first word of "$ac_prog", so it can be a program name with args.
18281 set dummy $ac_prog; ac_word=$2
18282 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18283 $as_echo_n "checking for $ac_word... " >&6; }
18284 if ${ac_cv_path_DSYMUTIL+:} false; then :
18285 $as_echo_n "(cached) " >&6
18286 else
18287 case $DSYMUTIL in
18288 [\\/]* | ?:[\\/]*)
18289 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18290 ;;
18291 *)
18292 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18293 for as_dir in $PATH
18294 do
18295 IFS=$as_save_IFS
18296 test -z "$as_dir" && as_dir=.
18297 for ac_exec_ext in '' $ac_executable_extensions; do
18298 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18299 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18300 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18301 break 2
18302 fi
18303 done
18304 done
18305 IFS=$as_save_IFS
18306
18307 ;;
18308 esac
18309 fi
18310 DSYMUTIL=$ac_cv_path_DSYMUTIL
18311 if test -n "$DSYMUTIL"; then
18312 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18313 $as_echo "$DSYMUTIL" >&6; }
18314 else
18315 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18316 $as_echo "no" >&6; }
18317 fi
18318
18319
18320 test -n "$DSYMUTIL" && break
18321 done
18322
18323 else
18324 # If it succeeded, then it was overridden by the user. We will use it
18325 # for the tool.
18326
18327 # First remove it from the list of overridden variables, so we can test
18328 # for unknown variables in the end.
18329 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18330
18331 # Check if the provided tool contains a complete path.
18332 tool_specified="$DSYMUTIL"
18333 tool_basename="${tool_specified##*/}"
18334 if test "x$tool_basename" = "x$tool_specified"; then
18335 # A command without a complete path is provided, search $PATH.
18336 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
18337 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
18338 # Extract the first word of "$tool_basename", so it can be a program name with args.
18339 set dummy $tool_basename; ac_word=$2
18340 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18341 $as_echo_n "checking for $ac_word... " >&6; }
18342 if ${ac_cv_path_DSYMUTIL+:} false; then :
18343 $as_echo_n "(cached) " >&6
18344 else
18345 case $DSYMUTIL in
18346 [\\/]* | ?:[\\/]*)
18347 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18348 ;;
18349 *)
18350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18351 for as_dir in $PATH
18352 do
18353 IFS=$as_save_IFS
18354 test -z "$as_dir" && as_dir=.
18355 for ac_exec_ext in '' $ac_executable_extensions; do
18356 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18357 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18358 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18359 break 2
18360 fi
18361 done
18362 done
18363 IFS=$as_save_IFS
18364
18365 ;;
18366 esac
18367 fi
18368 DSYMUTIL=$ac_cv_path_DSYMUTIL
18369 if test -n "$DSYMUTIL"; then
18370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18371 $as_echo "$DSYMUTIL" >&6; }
18372 else
18373 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18374 $as_echo "no" >&6; }
18375 fi
18376
18377
18378 if test "x$DSYMUTIL" = x; then
18379 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18380 fi
18381 else
18382 # Otherwise we believe it is a complete path. Use it as it is.
18383 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
18384 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
18385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
18386 $as_echo_n "checking for DSYMUTIL... " >&6; }
18387 if test ! -x "$tool_specified"; then
18388 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18389 $as_echo "not found" >&6; }
18390 as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
18391 fi
18392 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18393 $as_echo "$tool_specified" >&6; }
18394 fi
18395 fi
18396 fi
18397
18398
18399
18400 if test "x$DSYMUTIL" = x; then
18401 as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
18402 fi
18403
18404
18405
18406
18407
18408 # Publish this variable in the help.
18409
18410
18411 if test "x$XATTR" = x; then
18412 # The variable is not set by user, try to locate tool using the code snippet
18413 for ac_prog in xattr
18414 do
18415 # Extract the first word of "$ac_prog", so it can be a program name with args.
18416 set dummy $ac_prog; ac_word=$2
18417 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18418 $as_echo_n "checking for $ac_word... " >&6; }
18419 if ${ac_cv_path_XATTR+:} false; then :
18420 $as_echo_n "(cached) " >&6
18421 else
18422 case $XATTR in
18423 [\\/]* | ?:[\\/]*)
18424 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18425 ;;
18426 *)
18427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18428 for as_dir in $PATH
18429 do
18430 IFS=$as_save_IFS
18431 test -z "$as_dir" && as_dir=.
18432 for ac_exec_ext in '' $ac_executable_extensions; do
18433 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18434 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18435 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18436 break 2
18437 fi
18438 done
18439 done
18440 IFS=$as_save_IFS
18441
18442 ;;
18443 esac
18444 fi
18445 XATTR=$ac_cv_path_XATTR
18446 if test -n "$XATTR"; then
18447 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18448 $as_echo "$XATTR" >&6; }
18449 else
18450 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18451 $as_echo "no" >&6; }
18452 fi
18453
18454
18455 test -n "$XATTR" && break
18456 done
18457
18458 else
18459 # The variable is set, but is it from the command line or the environment?
18460
18461 # Try to remove the string !XATTR! from our list.
18462 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
18463 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18464 # If it failed, the variable was not from the command line. Ignore it,
18465 # but warn the user (except for BASH, which is always set by the calling BASH).
18466 if test "xXATTR" != xBASH; then
18467 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
18468 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
18469 fi
18470 # Try to locate tool using the code snippet
18471 for ac_prog in xattr
18472 do
18473 # Extract the first word of "$ac_prog", so it can be a program name with args.
18474 set dummy $ac_prog; ac_word=$2
18475 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18476 $as_echo_n "checking for $ac_word... " >&6; }
18477 if ${ac_cv_path_XATTR+:} false; then :
18478 $as_echo_n "(cached) " >&6
18479 else
18480 case $XATTR in
18481 [\\/]* | ?:[\\/]*)
18482 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18483 ;;
18484 *)
18485 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18486 for as_dir in $PATH
18487 do
18488 IFS=$as_save_IFS
18489 test -z "$as_dir" && as_dir=.
18490 for ac_exec_ext in '' $ac_executable_extensions; do
18491 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18492 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18493 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18494 break 2
18495 fi
18496 done
18497 done
18498 IFS=$as_save_IFS
18499
18500 ;;
18501 esac
18502 fi
18503 XATTR=$ac_cv_path_XATTR
18504 if test -n "$XATTR"; then
18505 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18506 $as_echo "$XATTR" >&6; }
18507 else
18508 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18509 $as_echo "no" >&6; }
18510 fi
18511
18512
18513 test -n "$XATTR" && break
18514 done
18515
18516 else
18517 # If it succeeded, then it was overridden by the user. We will use it
18518 # for the tool.
18519
18520 # First remove it from the list of overridden variables, so we can test
18521 # for unknown variables in the end.
18522 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18523
18524 # Check if the provided tool contains a complete path.
18525 tool_specified="$XATTR"
18526 tool_basename="${tool_specified##*/}"
18527 if test "x$tool_basename" = "x$tool_specified"; then
18528 # A command without a complete path is provided, search $PATH.
18529 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
18530 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
18531 # Extract the first word of "$tool_basename", so it can be a program name with args.
18532 set dummy $tool_basename; ac_word=$2
18533 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18534 $as_echo_n "checking for $ac_word... " >&6; }
18535 if ${ac_cv_path_XATTR+:} false; then :
18536 $as_echo_n "(cached) " >&6
18537 else
18538 case $XATTR in
18539 [\\/]* | ?:[\\/]*)
18540 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18541 ;;
18542 *)
18543 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18544 for as_dir in $PATH
18545 do
18546 IFS=$as_save_IFS
18547 test -z "$as_dir" && as_dir=.
18548 for ac_exec_ext in '' $ac_executable_extensions; do
18549 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18550 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18551 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18552 break 2
18553 fi
18554 done
18555 done
18556 IFS=$as_save_IFS
18557
18558 ;;
18559 esac
18560 fi
18561 XATTR=$ac_cv_path_XATTR
18562 if test -n "$XATTR"; then
18563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18564 $as_echo "$XATTR" >&6; }
18565 else
18566 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18567 $as_echo "no" >&6; }
18568 fi
18569
18570
18571 if test "x$XATTR" = x; then
18572 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18573 fi
18574 else
18575 # Otherwise we believe it is a complete path. Use it as it is.
18576 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
18577 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
18578 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
18579 $as_echo_n "checking for XATTR... " >&6; }
18580 if test ! -x "$tool_specified"; then
18581 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18582 $as_echo "not found" >&6; }
18583 as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
18584 fi
18585 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18586 $as_echo "$tool_specified" >&6; }
18587 fi
18588 fi
18589 fi
18590
18591
18592
18593 if test "x$XATTR" = x; then
18594 as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
18595 fi
18596
18597
18598
18599
18600 # Publish this variable in the help.
18601
18602
18603 if test "x$CODESIGN" = x; then
18604 # The variable is not set by user, try to locate tool using the code snippet
18605 for ac_prog in codesign
18606 do
18607 # Extract the first word of "$ac_prog", so it can be a program name with args.
18608 set dummy $ac_prog; ac_word=$2
18609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18610 $as_echo_n "checking for $ac_word... " >&6; }
18611 if ${ac_cv_path_CODESIGN+:} false; then :
18612 $as_echo_n "(cached) " >&6
18613 else
18614 case $CODESIGN in
18615 [\\/]* | ?:[\\/]*)
18616 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18617 ;;
18618 *)
18619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18620 for as_dir in $PATH
18621 do
18622 IFS=$as_save_IFS
18623 test -z "$as_dir" && as_dir=.
18624 for ac_exec_ext in '' $ac_executable_extensions; do
18625 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18626 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18627 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18628 break 2
18629 fi
18630 done
18631 done
18632 IFS=$as_save_IFS
18633
18634 ;;
18635 esac
18636 fi
18637 CODESIGN=$ac_cv_path_CODESIGN
18638 if test -n "$CODESIGN"; then
18639 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
18640 $as_echo "$CODESIGN" >&6; }
18641 else
18642 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18643 $as_echo "no" >&6; }
18644 fi
18645
18646
18647 test -n "$CODESIGN" && break
18648 done
18649
18650 else
18651 # The variable is set, but is it from the command line or the environment?
18652
18653 # Try to remove the string !CODESIGN! from our list.
18654 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
18655 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18656 # If it failed, the variable was not from the command line. Ignore it,
18657 # but warn the user (except for BASH, which is always set by the calling BASH).
18658 if test "xCODESIGN" != xBASH; then
18659 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
18660 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
18661 fi
18662 # Try to locate tool using the code snippet
18663 for ac_prog in codesign
18664 do
18665 # Extract the first word of "$ac_prog", so it can be a program name with args.
18666 set dummy $ac_prog; ac_word=$2
18667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18668 $as_echo_n "checking for $ac_word... " >&6; }
18669 if ${ac_cv_path_CODESIGN+:} false; then :
18670 $as_echo_n "(cached) " >&6
18671 else
18672 case $CODESIGN in
18673 [\\/]* | ?:[\\/]*)
18674 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18675 ;;
18676 *)
18677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18678 for as_dir in $PATH
18679 do
18680 IFS=$as_save_IFS
18681 test -z "$as_dir" && as_dir=.
18682 for ac_exec_ext in '' $ac_executable_extensions; do
18683 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18684 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18685 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18686 break 2
18687 fi
18688 done
18689 done
18690 IFS=$as_save_IFS
18691
18692 ;;
18693 esac
18694 fi
18695 CODESIGN=$ac_cv_path_CODESIGN
18696 if test -n "$CODESIGN"; then
18697 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
18698 $as_echo "$CODESIGN" >&6; }
18699 else
18700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18701 $as_echo "no" >&6; }
18702 fi
18703
18704
18705 test -n "$CODESIGN" && break
18706 done
18707
18708 else
18709 # If it succeeded, then it was overridden by the user. We will use it
18710 # for the tool.
18711
18712 # First remove it from the list of overridden variables, so we can test
18713 # for unknown variables in the end.
18714 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18715
18716 # Check if the provided tool contains a complete path.
18717 tool_specified="$CODESIGN"
18718 tool_basename="${tool_specified##*/}"
18719 if test "x$tool_basename" = "x$tool_specified"; then
18720 # A command without a complete path is provided, search $PATH.
18721 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
18722 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
18723 # Extract the first word of "$tool_basename", so it can be a program name with args.
18724 set dummy $tool_basename; ac_word=$2
18725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18726 $as_echo_n "checking for $ac_word... " >&6; }
18727 if ${ac_cv_path_CODESIGN+:} false; then :
18728 $as_echo_n "(cached) " >&6
18729 else
18730 case $CODESIGN in
18731 [\\/]* | ?:[\\/]*)
18732 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18733 ;;
18734 *)
18735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18736 for as_dir in $PATH
18737 do
18738 IFS=$as_save_IFS
18739 test -z "$as_dir" && as_dir=.
18740 for ac_exec_ext in '' $ac_executable_extensions; do
18741 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18742 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18743 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18744 break 2
18745 fi
18746 done
18747 done
18748 IFS=$as_save_IFS
18749
18750 ;;
18751 esac
18752 fi
18753 CODESIGN=$ac_cv_path_CODESIGN
18754 if test -n "$CODESIGN"; then
18755 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
18756 $as_echo "$CODESIGN" >&6; }
18757 else
18758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18759 $as_echo "no" >&6; }
18760 fi
18761
18762
18763 if test "x$CODESIGN" = x; then
18764 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18765 fi
18766 else
18767 # Otherwise we believe it is a complete path. Use it as it is.
18768 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
18769 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
18770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
18771 $as_echo_n "checking for CODESIGN... " >&6; }
18772 if test ! -x "$tool_specified"; then
18773 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18774 $as_echo "not found" >&6; }
18775 as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
18776 fi
18777 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18778 $as_echo "$tool_specified" >&6; }
18779 fi
18780 fi
18781 fi
18782
18783
18784 if test "x$CODESIGN" != "x"; then
18785 # Verify that the openjdk_codesign certificate is present
18786 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
18787 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
18788 rm -f codesign-testfile
18789 touch codesign-testfile
18790 codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
18791 rm -f codesign-testfile
18792 if test "x$CODESIGN" = x; then
18793 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18794 $as_echo "no" >&6; }
18795 else
18796 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18797 $as_echo "yes" >&6; }
18798 fi
18799 fi
18800 fi
18801
18802
18803 # Check if pkg-config is available.
24825 if test ! -f "$path" && test ! -d "$path"; then
24826 as_fn_error $? "The path of JT_HOME, which resolves as \"$path\", is not found." "$LINENO" 5
24827 fi
24828
24829 JT_HOME="`cd "$path"; $THEPWDCMD -L`"
24830 fi
24831
24832
24833 # jtreg win32 script works for everybody
24834 JTREGEXE="$JT_HOME/bin/jtreg"
24835
24836 if test ! -f "$JTREGEXE"; then
24837 as_fn_error $? "JTReg executable does not exist: $JTREGEXE" "$LINENO" 5
24838 fi
24839
24840 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
24841 $as_echo "$JTREGEXE" >&6; }
24842 else
24843 # try to find jtreg on path
24844
24845
24846
24847 # Publish this variable in the help.
24848
24849
24850 if test "x$JTREGEXE" = x; then
24851 # The variable is not set by user, try to locate tool using the code snippet
24852 for ac_prog in jtreg
24853 do
24854 # Extract the first word of "$ac_prog", so it can be a program name with args.
24855 set dummy $ac_prog; ac_word=$2
24856 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24857 $as_echo_n "checking for $ac_word... " >&6; }
24858 if ${ac_cv_path_JTREGEXE+:} false; then :
24859 $as_echo_n "(cached) " >&6
24860 else
24861 case $JTREGEXE in
24862 [\\/]* | ?:[\\/]*)
24863 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
24864 ;;
24865 *)
24866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24867 for as_dir in $PATH
24868 do
24869 IFS=$as_save_IFS
24870 test -z "$as_dir" && as_dir=.
24871 for ac_exec_ext in '' $ac_executable_extensions; do
24872 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24873 ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
24874 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24875 break 2
24876 fi
24877 done
24878 done
24879 IFS=$as_save_IFS
24880
24881 ;;
24882 esac
24883 fi
24884 JTREGEXE=$ac_cv_path_JTREGEXE
24885 if test -n "$JTREGEXE"; then
24886 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
24887 $as_echo "$JTREGEXE" >&6; }
24888 else
24889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24890 $as_echo "no" >&6; }
24891 fi
24892
24893
24894 test -n "$JTREGEXE" && break
24895 done
24896
24897 else
24898 # The variable is set, but is it from the command line or the environment?
24899
24900 # Try to remove the string !JTREGEXE! from our list.
24901 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JTREGEXE!/}
24902 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
24903 # If it failed, the variable was not from the command line. Ignore it,
24904 # but warn the user (except for BASH, which is always set by the calling BASH).
24905 if test "xJTREGEXE" != xBASH; then
24906 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
24907 $as_echo "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
24908 fi
24909 # Try to locate tool using the code snippet
24910 for ac_prog in jtreg
24911 do
24912 # Extract the first word of "$ac_prog", so it can be a program name with args.
24913 set dummy $ac_prog; ac_word=$2
24914 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24915 $as_echo_n "checking for $ac_word... " >&6; }
24916 if ${ac_cv_path_JTREGEXE+:} false; then :
24917 $as_echo_n "(cached) " >&6
24918 else
24919 case $JTREGEXE in
24920 [\\/]* | ?:[\\/]*)
24921 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
24922 ;;
24923 *)
24924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24925 for as_dir in $PATH
24926 do
24927 IFS=$as_save_IFS
24928 test -z "$as_dir" && as_dir=.
24929 for ac_exec_ext in '' $ac_executable_extensions; do
24935 done
24936 done
24937 IFS=$as_save_IFS
24938
24939 ;;
24940 esac
24941 fi
24942 JTREGEXE=$ac_cv_path_JTREGEXE
24943 if test -n "$JTREGEXE"; then
24944 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
24945 $as_echo "$JTREGEXE" >&6; }
24946 else
24947 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24948 $as_echo "no" >&6; }
24949 fi
24950
24951
24952 test -n "$JTREGEXE" && break
24953 done
24954
24955 else
24956 # If it succeeded, then it was overridden by the user. We will use it
24957 # for the tool.
24958
24959 # First remove it from the list of overridden variables, so we can test
24960 # for unknown variables in the end.
24961 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
24962
24963 # Check if the provided tool contains a complete path.
24964 tool_specified="$JTREGEXE"
24965 tool_basename="${tool_specified##*/}"
24966 if test "x$tool_basename" = "x$tool_specified"; then
24967 # A command without a complete path is provided, search $PATH.
24968 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
24969 $as_echo "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
24970 # Extract the first word of "$tool_basename", so it can be a program name with args.
24971 set dummy $tool_basename; ac_word=$2
24972 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24973 $as_echo_n "checking for $ac_word... " >&6; }
24974 if ${ac_cv_path_JTREGEXE+:} false; then :
24975 $as_echo_n "(cached) " >&6
24976 else
24977 case $JTREGEXE in
24978 [\\/]* | ?:[\\/]*)
24979 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
24980 ;;
24981 *)
24982 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24983 for as_dir in $PATH
24984 do
24985 IFS=$as_save_IFS
24986 test -z "$as_dir" && as_dir=.
24987 for ac_exec_ext in '' $ac_executable_extensions; do
24988 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24989 ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
24990 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24991 break 2
24992 fi
24993 done
24994 done
24995 IFS=$as_save_IFS
24996
24997 ;;
24998 esac
24999 fi
25000 JTREGEXE=$ac_cv_path_JTREGEXE
25001 if test -n "$JTREGEXE"; then
25002 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
25003 $as_echo "$JTREGEXE" >&6; }
25004 else
25005 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
25006 $as_echo "no" >&6; }
25007 fi
25008
25009
25010 if test "x$JTREGEXE" = x; then
25011 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
25012 fi
25013 else
25014 # Otherwise we believe it is a complete path. Use it as it is.
25015 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
25016 $as_echo "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
25017 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
25018 $as_echo_n "checking for JTREGEXE... " >&6; }
25019 if test ! -x "$tool_specified"; then
25020 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
25021 $as_echo "not found" >&6; }
25022 as_fn_error $? "User supplied tool JTREGEXE=$tool_specified does not exist or is not executable" "$LINENO" 5
25023 fi
25024 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
25025 $as_echo "$tool_specified" >&6; }
25026 fi
25027 fi
25028 fi
25029
25030
25031
25032 if test "x$JTREGEXE" = x; then
25033 as_fn_error $? "Could not find required tool for JTREGEXE" "$LINENO" 5
25034 fi
25035
25036
25037 JT_HOME="`$DIRNAME $JTREGEXE`"
25038 fi
25039 fi
25040
25041
25042
25043
25044
25045 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
25046
25047 # Store path to cygwin link.exe to help excluding it when searching for
25048 # VS linker. This must be done before changing the PATH when looking for VS.
25049 # Extract the first word of "link", so it can be a program name with args.
25050 set dummy link; ac_word=$2
25051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
25052 $as_echo_n "checking for $ac_word... " >&6; }
25053 if ${ac_cv_path_CYGWIN_LINK+:} false; then :
26302
26303
26304
26305 # If --build AND --host is set, then the configure script will find any
26306 # cross compilation tools in the PATH. Cross compilation tools
26307 # follows the cross compilation standard where they are prefixed with ${host}.
26308 # For example the binary i686-sun-solaris2.10-gcc
26309 # will cross compile for i686-sun-solaris2.10
26310 # If neither of build and host is not set, then build=host and the
26311 # default compiler found in the path will be used.
26312 # Setting only --host, does not seem to be really supported.
26313 # Please set both --build and --host if you want to cross compile.
26314
26315 if test "x$COMPILE_TYPE" = "xcross"; then
26316 # Now we to find a C/C++ compiler that can build executables for the build
26317 # platform. We can't use the AC_PROG_CC macro, since it can only be used
26318 # once. Also, we need to do this before adding a tools dir to the path,
26319 # otherwise we might pick up cross-compilers which don't use standard naming.
26320 # Otherwise, we'll set the BUILD_tools to the native tools, but that'll have
26321 # to wait until they are properly discovered.
26322
26323
26324 # Publish this variable in the help.
26325
26326
26327 if test "x$BUILD_CC" = x; then
26328 # The variable is not set by user, try to locate tool using the code snippet
26329 for ac_prog in cl cc gcc
26330 do
26331 # Extract the first word of "$ac_prog", so it can be a program name with args.
26332 set dummy $ac_prog; ac_word=$2
26333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26334 $as_echo_n "checking for $ac_word... " >&6; }
26335 if ${ac_cv_path_BUILD_CC+:} false; then :
26336 $as_echo_n "(cached) " >&6
26337 else
26338 case $BUILD_CC in
26339 [\\/]* | ?:[\\/]*)
26340 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
26341 ;;
26342 *)
26343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26344 for as_dir in $PATH
26345 do
26346 IFS=$as_save_IFS
26347 test -z "$as_dir" && as_dir=.
26348 for ac_exec_ext in '' $ac_executable_extensions; do
26349 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26350 ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
26351 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26352 break 2
26353 fi
26354 done
26355 done
26356 IFS=$as_save_IFS
26357
26358 ;;
26359 esac
26360 fi
26361 BUILD_CC=$ac_cv_path_BUILD_CC
26362 if test -n "$BUILD_CC"; then
26363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
26364 $as_echo "$BUILD_CC" >&6; }
26365 else
26366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26367 $as_echo "no" >&6; }
26368 fi
26369
26370
26371 test -n "$BUILD_CC" && break
26372 done
26373
26374 else
26375 # The variable is set, but is it from the command line or the environment?
26376
26377 # Try to remove the string !BUILD_CC! from our list.
26378 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_CC!/}
26379 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
26380 # If it failed, the variable was not from the command line. Ignore it,
26381 # but warn the user (except for BASH, which is always set by the calling BASH).
26382 if test "xBUILD_CC" != xBASH; then
26383 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
26384 $as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
26385 fi
26386 # Try to locate tool using the code snippet
26387 for ac_prog in cl cc gcc
26388 do
26389 # Extract the first word of "$ac_prog", so it can be a program name with args.
26390 set dummy $ac_prog; ac_word=$2
26391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26392 $as_echo_n "checking for $ac_word... " >&6; }
26393 if ${ac_cv_path_BUILD_CC+:} false; then :
26394 $as_echo_n "(cached) " >&6
26395 else
26396 case $BUILD_CC in
26397 [\\/]* | ?:[\\/]*)
26398 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
26399 ;;
26400 *)
26401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26402 for as_dir in $PATH
26403 do
26404 IFS=$as_save_IFS
26405 test -z "$as_dir" && as_dir=.
26406 for ac_exec_ext in '' $ac_executable_extensions; do
26412 done
26413 done
26414 IFS=$as_save_IFS
26415
26416 ;;
26417 esac
26418 fi
26419 BUILD_CC=$ac_cv_path_BUILD_CC
26420 if test -n "$BUILD_CC"; then
26421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
26422 $as_echo "$BUILD_CC" >&6; }
26423 else
26424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26425 $as_echo "no" >&6; }
26426 fi
26427
26428
26429 test -n "$BUILD_CC" && break
26430 done
26431
26432 else
26433 # If it succeeded, then it was overridden by the user. We will use it
26434 # for the tool.
26435
26436 # First remove it from the list of overridden variables, so we can test
26437 # for unknown variables in the end.
26438 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
26439
26440 # Check if the provided tool contains a complete path.
26441 tool_specified="$BUILD_CC"
26442 tool_basename="${tool_specified##*/}"
26443 if test "x$tool_basename" = "x$tool_specified"; then
26444 # A command without a complete path is provided, search $PATH.
26445 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
26446 $as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
26447 # Extract the first word of "$tool_basename", so it can be a program name with args.
26448 set dummy $tool_basename; ac_word=$2
26449 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26450 $as_echo_n "checking for $ac_word... " >&6; }
26451 if ${ac_cv_path_BUILD_CC+:} false; then :
26452 $as_echo_n "(cached) " >&6
26453 else
26454 case $BUILD_CC in
26455 [\\/]* | ?:[\\/]*)
26456 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
26457 ;;
26458 *)
26459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26460 for as_dir in $PATH
26461 do
26462 IFS=$as_save_IFS
26463 test -z "$as_dir" && as_dir=.
26464 for ac_exec_ext in '' $ac_executable_extensions; do
26465 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26466 ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
26467 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26468 break 2
26469 fi
26470 done
26471 done
26472 IFS=$as_save_IFS
26473
26474 ;;
26475 esac
26476 fi
26477 BUILD_CC=$ac_cv_path_BUILD_CC
26478 if test -n "$BUILD_CC"; then
26479 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
26480 $as_echo "$BUILD_CC" >&6; }
26481 else
26482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26483 $as_echo "no" >&6; }
26484 fi
26485
26486
26487 if test "x$BUILD_CC" = x; then
26488 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
26489 fi
26490 else
26491 # Otherwise we believe it is a complete path. Use it as it is.
26492 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
26493 $as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
26494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
26495 $as_echo_n "checking for BUILD_CC... " >&6; }
26496 if test ! -x "$tool_specified"; then
26497 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
26498 $as_echo "not found" >&6; }
26499 as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
26500 fi
26501 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
26502 $as_echo "$tool_specified" >&6; }
26503 fi
26504 fi
26505 fi
26506
26507
26508
26509 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26510
26511 # First separate the path from the arguments. This will split at the first
26512 # space.
26513 complete="$BUILD_CC"
26514 path="${complete%% *}"
26515 tmp="$complete EOL"
26516 arguments="${tmp#* }"
26517
26518 # Input might be given as Windows format, start by converting to
26519 # unix format.
26520 new_path=`$CYGPATH -u "$path"`
26521
26522 # Now try to locate executable using which
26523 new_path=`$WHICH "$new_path" 2> /dev/null`
26524 # bat and cmd files are not always considered executable in cygwin causing which
26525 # to not find them
26526 if test "x$new_path" = x \
26527 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
26754 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
26755 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
26756 fi
26757 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
26758 fi
26759 fi
26760
26761 # Now join together the path and the arguments once again
26762 if test "x$arguments" != xEOL; then
26763 new_complete="$new_path ${arguments% *}"
26764 else
26765 new_complete="$new_path"
26766 fi
26767
26768 if test "x$complete" != "x$new_complete"; then
26769 BUILD_CC="$new_complete"
26770 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
26771 $as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
26772 fi
26773
26774
26775
26776 # Publish this variable in the help.
26777
26778
26779 if test "x$BUILD_CXX" = x; then
26780 # The variable is not set by user, try to locate tool using the code snippet
26781 for ac_prog in cl CC g++
26782 do
26783 # Extract the first word of "$ac_prog", so it can be a program name with args.
26784 set dummy $ac_prog; ac_word=$2
26785 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26786 $as_echo_n "checking for $ac_word... " >&6; }
26787 if ${ac_cv_path_BUILD_CXX+:} false; then :
26788 $as_echo_n "(cached) " >&6
26789 else
26790 case $BUILD_CXX in
26791 [\\/]* | ?:[\\/]*)
26792 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
26793 ;;
26794 *)
26795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26796 for as_dir in $PATH
26797 do
26798 IFS=$as_save_IFS
26799 test -z "$as_dir" && as_dir=.
26800 for ac_exec_ext in '' $ac_executable_extensions; do
26801 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26802 ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
26803 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26804 break 2
26805 fi
26806 done
26807 done
26808 IFS=$as_save_IFS
26809
26810 ;;
26811 esac
26812 fi
26813 BUILD_CXX=$ac_cv_path_BUILD_CXX
26814 if test -n "$BUILD_CXX"; then
26815 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
26816 $as_echo "$BUILD_CXX" >&6; }
26817 else
26818 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26819 $as_echo "no" >&6; }
26820 fi
26821
26822
26823 test -n "$BUILD_CXX" && break
26824 done
26825
26826 else
26827 # The variable is set, but is it from the command line or the environment?
26828
26829 # Try to remove the string !BUILD_CXX! from our list.
26830 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_CXX!/}
26831 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
26832 # If it failed, the variable was not from the command line. Ignore it,
26833 # but warn the user (except for BASH, which is always set by the calling BASH).
26834 if test "xBUILD_CXX" != xBASH; then
26835 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
26836 $as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
26837 fi
26838 # Try to locate tool using the code snippet
26839 for ac_prog in cl CC g++
26840 do
26841 # Extract the first word of "$ac_prog", so it can be a program name with args.
26842 set dummy $ac_prog; ac_word=$2
26843 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26844 $as_echo_n "checking for $ac_word... " >&6; }
26845 if ${ac_cv_path_BUILD_CXX+:} false; then :
26846 $as_echo_n "(cached) " >&6
26847 else
26848 case $BUILD_CXX in
26849 [\\/]* | ?:[\\/]*)
26850 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
26851 ;;
26852 *)
26853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26854 for as_dir in $PATH
26855 do
26856 IFS=$as_save_IFS
26857 test -z "$as_dir" && as_dir=.
26858 for ac_exec_ext in '' $ac_executable_extensions; do
26864 done
26865 done
26866 IFS=$as_save_IFS
26867
26868 ;;
26869 esac
26870 fi
26871 BUILD_CXX=$ac_cv_path_BUILD_CXX
26872 if test -n "$BUILD_CXX"; then
26873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
26874 $as_echo "$BUILD_CXX" >&6; }
26875 else
26876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26877 $as_echo "no" >&6; }
26878 fi
26879
26880
26881 test -n "$BUILD_CXX" && break
26882 done
26883
26884 else
26885 # If it succeeded, then it was overridden by the user. We will use it
26886 # for the tool.
26887
26888 # First remove it from the list of overridden variables, so we can test
26889 # for unknown variables in the end.
26890 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
26891
26892 # Check if the provided tool contains a complete path.
26893 tool_specified="$BUILD_CXX"
26894 tool_basename="${tool_specified##*/}"
26895 if test "x$tool_basename" = "x$tool_specified"; then
26896 # A command without a complete path is provided, search $PATH.
26897 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
26898 $as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
26899 # Extract the first word of "$tool_basename", so it can be a program name with args.
26900 set dummy $tool_basename; ac_word=$2
26901 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26902 $as_echo_n "checking for $ac_word... " >&6; }
26903 if ${ac_cv_path_BUILD_CXX+:} false; then :
26904 $as_echo_n "(cached) " >&6
26905 else
26906 case $BUILD_CXX in
26907 [\\/]* | ?:[\\/]*)
26908 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
26909 ;;
26910 *)
26911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26912 for as_dir in $PATH
26913 do
26914 IFS=$as_save_IFS
26915 test -z "$as_dir" && as_dir=.
26916 for ac_exec_ext in '' $ac_executable_extensions; do
26917 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26918 ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
26919 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26920 break 2
26921 fi
26922 done
26923 done
26924 IFS=$as_save_IFS
26925
26926 ;;
26927 esac
26928 fi
26929 BUILD_CXX=$ac_cv_path_BUILD_CXX
26930 if test -n "$BUILD_CXX"; then
26931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
26932 $as_echo "$BUILD_CXX" >&6; }
26933 else
26934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26935 $as_echo "no" >&6; }
26936 fi
26937
26938
26939 if test "x$BUILD_CXX" = x; then
26940 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
26941 fi
26942 else
26943 # Otherwise we believe it is a complete path. Use it as it is.
26944 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
26945 $as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
26946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
26947 $as_echo_n "checking for BUILD_CXX... " >&6; }
26948 if test ! -x "$tool_specified"; then
26949 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
26950 $as_echo "not found" >&6; }
26951 as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
26952 fi
26953 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
26954 $as_echo "$tool_specified" >&6; }
26955 fi
26956 fi
26957 fi
26958
26959
26960
26961 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26962
26963 # First separate the path from the arguments. This will split at the first
26964 # space.
26965 complete="$BUILD_CXX"
26966 path="${complete%% *}"
26967 tmp="$complete EOL"
26968 arguments="${tmp#* }"
26969
26970 # Input might be given as Windows format, start by converting to
26971 # unix format.
26972 new_path=`$CYGPATH -u "$path"`
26973
26974 # Now try to locate executable using which
26975 new_path=`$WHICH "$new_path" 2> /dev/null`
26976 # bat and cmd files are not always considered executable in cygwin causing which
26977 # to not find them
26978 if test "x$new_path" = x \
26979 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
27193 done
27194 IFS="$IFS_save"
27195 else
27196 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving BUILD_CXX (as $path) failed, using $path directly." >&5
27197 $as_echo "$as_me: Resolving BUILD_CXX (as $path) failed, using $path directly." >&6;}
27198 new_path="$path"
27199 fi
27200
27201 if test "x$new_path" = x; then
27202 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
27203 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
27204 has_space=`$ECHO "$complete" | $GREP " "`
27205 if test "x$has_space" != x; then
27206 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
27207 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
27208 fi
27209 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
27210 fi
27211 fi
27212
27213 # Now join together the path and the arguments once again
27214 if test "x$arguments" != xEOL; then
27215 new_complete="$new_path ${arguments% *}"
27216 else
27217 new_complete="$new_path"
27218 fi
27219
27220 if test "x$complete" != "x$new_complete"; then
27221 BUILD_CXX="$new_complete"
27222 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
27223 $as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
27224 fi
27225
27226
27227
27228 # Publish this variable in the help.
27229
27230
27231 if test "x$BUILD_LD" = x; then
27232 # The variable is not set by user, try to locate tool using the code snippet
27233 for ac_prog in ld
27234 do
27235 # Extract the first word of "$ac_prog", so it can be a program name with args.
27236 set dummy $ac_prog; ac_word=$2
27237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27238 $as_echo_n "checking for $ac_word... " >&6; }
27239 if ${ac_cv_path_BUILD_LD+:} false; then :
27240 $as_echo_n "(cached) " >&6
27241 else
27242 case $BUILD_LD in
27243 [\\/]* | ?:[\\/]*)
27244 ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
27245 ;;
27246 *)
27247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27248 for as_dir in $PATH
27249 do
27250 IFS=$as_save_IFS
27251 test -z "$as_dir" && as_dir=.
27252 for ac_exec_ext in '' $ac_executable_extensions; do
27253 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27254 ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
27255 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27256 break 2
27257 fi
27258 done
27259 done
27260 IFS=$as_save_IFS
27261
27262 ;;
27263 esac
27264 fi
27265 BUILD_LD=$ac_cv_path_BUILD_LD
27266 if test -n "$BUILD_LD"; then
27267 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
27268 $as_echo "$BUILD_LD" >&6; }
27269 else
27270 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27271 $as_echo "no" >&6; }
27272 fi
27273
27274
27275 test -n "$BUILD_LD" && break
27276 done
27277
27278 else
27279 # The variable is set, but is it from the command line or the environment?
27280
27281 # Try to remove the string !BUILD_LD! from our list.
27282 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_LD!/}
27283 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
27284 # If it failed, the variable was not from the command line. Ignore it,
27285 # but warn the user (except for BASH, which is always set by the calling BASH).
27286 if test "xBUILD_LD" != xBASH; then
27287 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&5
27288 $as_echo "$as_me: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&2;}
27289 fi
27290 # Try to locate tool using the code snippet
27291 for ac_prog in ld
27292 do
27293 # Extract the first word of "$ac_prog", so it can be a program name with args.
27294 set dummy $ac_prog; ac_word=$2
27295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27296 $as_echo_n "checking for $ac_word... " >&6; }
27297 if ${ac_cv_path_BUILD_LD+:} false; then :
27298 $as_echo_n "(cached) " >&6
27299 else
27300 case $BUILD_LD in
27301 [\\/]* | ?:[\\/]*)
27302 ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
27303 ;;
27304 *)
27305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27306 for as_dir in $PATH
27307 do
27308 IFS=$as_save_IFS
27309 test -z "$as_dir" && as_dir=.
27310 for ac_exec_ext in '' $ac_executable_extensions; do
27311 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27312 ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
27313 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27314 break 2
27315 fi
27316 done
27317 done
27318 IFS=$as_save_IFS
27319
27320 ;;
27321 esac
27322 fi
27323 BUILD_LD=$ac_cv_path_BUILD_LD
27324 if test -n "$BUILD_LD"; then
27325 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
27326 $as_echo "$BUILD_LD" >&6; }
27327 else
27328 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27329 $as_echo "no" >&6; }
27330 fi
27331
27332
27333 test -n "$BUILD_LD" && break
27334 done
27335
27336 else
27337 # If it succeeded, then it was overridden by the user. We will use it
27338 # for the tool.
27339
27340 # First remove it from the list of overridden variables, so we can test
27341 # for unknown variables in the end.
27342 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
27343
27344 # Check if the provided tool contains a complete path.
27345 tool_specified="$BUILD_LD"
27346 tool_basename="${tool_specified##*/}"
27347 if test "x$tool_basename" = "x$tool_specified"; then
27348 # A command without a complete path is provided, search $PATH.
27349 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_LD=$tool_basename" >&5
27350 $as_echo "$as_me: Will search for user supplied tool BUILD_LD=$tool_basename" >&6;}
27351 # Extract the first word of "$tool_basename", so it can be a program name with args.
27352 set dummy $tool_basename; ac_word=$2
27353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
27354 $as_echo_n "checking for $ac_word... " >&6; }
27355 if ${ac_cv_path_BUILD_LD+:} false; then :
27356 $as_echo_n "(cached) " >&6
27357 else
27358 case $BUILD_LD in
27359 [\\/]* | ?:[\\/]*)
27360 ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
27361 ;;
27362 *)
27363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
27364 for as_dir in $PATH
27365 do
27366 IFS=$as_save_IFS
27367 test -z "$as_dir" && as_dir=.
27368 for ac_exec_ext in '' $ac_executable_extensions; do
27369 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
27370 ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
27371 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
27372 break 2
27373 fi
27374 done
27375 done
27376 IFS=$as_save_IFS
27377
27378 ;;
27379 esac
27380 fi
27381 BUILD_LD=$ac_cv_path_BUILD_LD
27382 if test -n "$BUILD_LD"; then
27383 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
27384 $as_echo "$BUILD_LD" >&6; }
27385 else
27386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
27387 $as_echo "no" >&6; }
27388 fi
27389
27390
27391 if test "x$BUILD_LD" = x; then
27392 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
27393 fi
27394 else
27395 # Otherwise we believe it is a complete path. Use it as it is.
27396 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_LD=$tool_specified" >&5
27397 $as_echo "$as_me: Will use user supplied tool BUILD_LD=$tool_specified" >&6;}
27398 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_LD" >&5
27399 $as_echo_n "checking for BUILD_LD... " >&6; }
27400 if test ! -x "$tool_specified"; then
27401 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
27402 $as_echo "not found" >&6; }
27403 as_fn_error $? "User supplied tool BUILD_LD=$tool_specified does not exist or is not executable" "$LINENO" 5
27404 fi
27405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
27406 $as_echo "$tool_specified" >&6; }
27407 fi
27408 fi
27409 fi
27410
27411
27412
27413 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27414
27415 # First separate the path from the arguments. This will split at the first
27416 # space.
27417 complete="$BUILD_LD"
27418 path="${complete%% *}"
27419 tmp="$complete EOL"
27420 arguments="${tmp#* }"
27421
27422 # Input might be given as Windows format, start by converting to
27423 # unix format.
27424 new_path=`$CYGPATH -u "$path"`
27425
27426 # Now try to locate executable using which
27427 new_path=`$WHICH "$new_path" 2> /dev/null`
27428 # bat and cmd files are not always considered executable in cygwin causing which
27429 # to not find them
27430 if test "x$new_path" = x \
27431 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
31388
31389 # Restore the flags to the user specified values.
31390 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
31391 CFLAGS="$ORG_CFLAGS"
31392 CXXFLAGS="$ORG_CXXFLAGS"
31393 OBJCFLAGS="$ORG_OBJCFLAGS"
31394
31395 LD="$CC"
31396 LDEXE="$CC"
31397 LDCXX="$CXX"
31398 LDEXECXX="$CXX"
31399
31400 # LDEXE is the linker to use, when creating executables.
31401
31402 # Linking C++ libraries.
31403
31404 # Linking C++ executables.
31405
31406
31407 if test "x$OPENJDK_TARGET_OS" != xwindows; then
31408
31409
31410 # Publish this variable in the help.
31411
31412
31413 if test "x$AR" = x; then
31414 # The variable is not set by user, try to locate tool using the code snippet
31415 if test -n "$ac_tool_prefix"; then
31416 for ac_prog in ar
31417 do
31418 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
31419 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
31420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
31421 $as_echo_n "checking for $ac_word... " >&6; }
31422 if ${ac_cv_prog_AR+:} false; then :
31423 $as_echo_n "(cached) " >&6
31424 else
31425 if test -n "$AR"; then
31426 ac_cv_prog_AR="$AR" # Let the user override the test.
31427 else
31428 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
31429 for as_dir in $PATH
31430 do
31431 IFS=$as_save_IFS
31432 test -z "$as_dir" && as_dir=.
31433 for ac_exec_ext in '' $ac_executable_extensions; do
31434 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
31435 ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
31436 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
31437 break 2
31438 fi
31439 done
31440 done
31441 IFS=$as_save_IFS
31442
31443 fi
31444 fi
31445 AR=$ac_cv_prog_AR
31446 if test -n "$AR"; then
31447 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
31448 $as_echo "$AR" >&6; }
31449 else
31450 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31451 $as_echo "no" >&6; }
31452 fi
31453
31454
31455 test -n "$AR" && break
31456 done
31457 fi
31458 if test -z "$AR"; then
31459 ac_ct_AR=$AR
31460 for ac_prog in ar
31461 do
31462 # Extract the first word of "$ac_prog", so it can be a program name with args.
31463 set dummy $ac_prog; ac_word=$2
31464 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
31465 $as_echo_n "checking for $ac_word... " >&6; }
31466 if ${ac_cv_prog_ac_ct_AR+:} false; then :
31467 $as_echo_n "(cached) " >&6
31468 else
31469 if test -n "$ac_ct_AR"; then
31470 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
31471 else
31472 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
31473 for as_dir in $PATH
31474 do
31475 IFS=$as_save_IFS
31476 test -z "$as_dir" && as_dir=.
31477 for ac_exec_ext in '' $ac_executable_extensions; do
31478 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
31479 ac_cv_prog_ac_ct_AR="$ac_prog"
31480 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
31481 break 2
31482 fi
31483 done
31484 done
31485 IFS=$as_save_IFS
31486
31487 fi
31488 fi
31489 ac_ct_AR=$ac_cv_prog_ac_ct_AR
31490 if test -n "$ac_ct_AR"; then
31491 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
31492 $as_echo "$ac_ct_AR" >&6; }
31493 else
31494 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31495 $as_echo "no" >&6; }
31496 fi
31497
31498
31499 test -n "$ac_ct_AR" && break
31500 done
31501
31502 if test "x$ac_ct_AR" = x; then
31503 AR=""
31504 else
31505 case $cross_compiling:$ac_tool_warned in
31506 yes:)
31507 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
31508 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
31509 ac_tool_warned=yes ;;
31510 esac
31511 AR=$ac_ct_AR
31512 fi
31513 fi
31514
31515 else
31516 # The variable is set, but is it from the command line or the environment?
31517
31518 # Try to remove the string !AR! from our list.
31519 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AR!/}
31520 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
31521 # If it failed, the variable was not from the command line. Ignore it,
31522 # but warn the user (except for BASH, which is always set by the calling BASH).
31523 if test "xAR" != xBASH; then
31524 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
31525 $as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
31526 fi
31527 # Try to locate tool using the code snippet
31528 if test -n "$ac_tool_prefix"; then
31529 for ac_prog in ar
31530 do
31531 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
31532 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
31533 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
31534 $as_echo_n "checking for $ac_word... " >&6; }
31535 if ${ac_cv_prog_AR+:} false; then :
31536 $as_echo_n "(cached) " >&6
31537 else
31538 if test -n "$AR"; then
31539 ac_cv_prog_AR="$AR" # Let the user override the test.
31540 else
31541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
31542 for as_dir in $PATH
31543 do
31544 IFS=$as_save_IFS
31545 test -z "$as_dir" && as_dir=.
31546 for ac_exec_ext in '' $ac_executable_extensions; do
31547 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
31548 ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
31549 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
31550 break 2
31551 fi
31552 done
31553 done
31554 IFS=$as_save_IFS
31555
31556 fi
31557 fi
31558 AR=$ac_cv_prog_AR
31559 if test -n "$AR"; then
31560 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
31561 $as_echo "$AR" >&6; }
31562 else
31563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31564 $as_echo "no" >&6; }
31565 fi
31566
31567
31568 test -n "$AR" && break
31569 done
31570 fi
31571 if test -z "$AR"; then
31572 ac_ct_AR=$AR
31573 for ac_prog in ar
31574 do
31575 # Extract the first word of "$ac_prog", so it can be a program name with args.
31576 set dummy $ac_prog; ac_word=$2
31577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
31578 $as_echo_n "checking for $ac_word... " >&6; }
31579 if ${ac_cv_prog_ac_ct_AR+:} false; then :
31580 $as_echo_n "(cached) " >&6
31581 else
31582 if test -n "$ac_ct_AR"; then
31583 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
31584 else
31585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
31586 for as_dir in $PATH
31587 do
31588 IFS=$as_save_IFS
31589 test -z "$as_dir" && as_dir=.
31590 for ac_exec_ext in '' $ac_executable_extensions; do
31591 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
31592 ac_cv_prog_ac_ct_AR="$ac_prog"
31593 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
31594 break 2
31595 fi
31596 done
31597 done
31598 IFS=$as_save_IFS
31599
31600 fi
31601 fi
31602 ac_ct_AR=$ac_cv_prog_ac_ct_AR
31603 if test -n "$ac_ct_AR"; then
31604 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
31605 $as_echo "$ac_ct_AR" >&6; }
31606 else
31607 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31608 $as_echo "no" >&6; }
31609 fi
31610
31611
31612 test -n "$ac_ct_AR" && break
31613 done
31614
31615 if test "x$ac_ct_AR" = x; then
31616 AR=""
31617 else
31618 case $cross_compiling:$ac_tool_warned in
31619 yes:)
31620 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
31621 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
31622 ac_tool_warned=yes ;;
31623 esac
31624 AR=$ac_ct_AR
31625 fi
31626 fi
31627
31628 else
31629 # If it succeeded, then it was overridden by the user. We will use it
31630 # for the tool.
31631
31632 # First remove it from the list of overridden variables, so we can test
31633 # for unknown variables in the end.
31634 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
31635
31636 # Check if the provided tool contains a complete path.
31637 tool_specified="$AR"
31638 tool_basename="${tool_specified##*/}"
31639 if test "x$tool_basename" = "x$tool_specified"; then
31640 # A command without a complete path is provided, search $PATH.
31641 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
31642 $as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
31643 # Extract the first word of "$tool_basename", so it can be a program name with args.
31644 set dummy $tool_basename; ac_word=$2
31645 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
31646 $as_echo_n "checking for $ac_word... " >&6; }
31647 if ${ac_cv_path_AR+:} false; then :
31648 $as_echo_n "(cached) " >&6
31649 else
31650 case $AR in
31651 [\\/]* | ?:[\\/]*)
31652 ac_cv_path_AR="$AR" # Let the user override the test with a path.
31653 ;;
31654 *)
31655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
31656 for as_dir in $PATH
31657 do
31658 IFS=$as_save_IFS
31659 test -z "$as_dir" && as_dir=.
31660 for ac_exec_ext in '' $ac_executable_extensions; do
31661 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
31662 ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
31663 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
31664 break 2
31665 fi
31666 done
31667 done
31668 IFS=$as_save_IFS
31669
31670 ;;
31671 esac
31672 fi
31673 AR=$ac_cv_path_AR
31674 if test -n "$AR"; then
31675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
31676 $as_echo "$AR" >&6; }
31677 else
31678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31679 $as_echo "no" >&6; }
31680 fi
31681
31682
31683 if test "x$AR" = x; then
31684 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
31685 fi
31686 else
31687 # Otherwise we believe it is a complete path. Use it as it is.
31688 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
31689 $as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
31690 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
31691 $as_echo_n "checking for AR... " >&6; }
31692 if test ! -x "$tool_specified"; then
31693 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
31694 $as_echo "not found" >&6; }
31695 as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
31696 fi
31697 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
31698 $as_echo "$tool_specified" >&6; }
31699 fi
31700 fi
31701 fi
31702
31703
31704
31705 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31706
31707 # First separate the path from the arguments. This will split at the first
31708 # space.
31709 complete="$AR"
31710 path="${complete%% *}"
31711 tmp="$complete EOL"
31712 arguments="${tmp#* }"
31713
31714 # Input might be given as Windows format, start by converting to
31715 # unix format.
31716 new_path=`$CYGPATH -u "$path"`
31717
31718 # Now try to locate executable using which
31719 new_path=`$WHICH "$new_path" 2> /dev/null`
31720 # bat and cmd files are not always considered executable in cygwin causing which
31721 # to not find them
31722 if test "x$new_path" = x \
31723 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
31724 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34473 # building the build platform executables. The cross-compilation
34474 # case needed to be done earlier, but this can only be done after
34475 # the native tools have been localized.
34476 BUILD_CC="$CC"
34477 BUILD_CXX="$CXX"
34478 BUILD_LD="$LD"
34479 fi
34480
34481 # for solaris we really need solaris tools, and not gnu equivalent
34482 # these seems to normally reside in /usr/ccs/bin so add that to path before
34483 # starting to probe
34484 #
34485 # NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH
34486 # so that it can be overriden --with-tools-dir
34487 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
34488 PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}"
34489 fi
34490
34491 # Find the right assembler.
34492 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
34493
34494
34495 # Publish this variable in the help.
34496
34497
34498 if test "x$AS" = x; then
34499 # The variable is not set by user, try to locate tool using the code snippet
34500 for ac_prog in as
34501 do
34502 # Extract the first word of "$ac_prog", so it can be a program name with args.
34503 set dummy $ac_prog; ac_word=$2
34504 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34505 $as_echo_n "checking for $ac_word... " >&6; }
34506 if ${ac_cv_path_AS+:} false; then :
34507 $as_echo_n "(cached) " >&6
34508 else
34509 case $AS in
34510 [\\/]* | ?:[\\/]*)
34511 ac_cv_path_AS="$AS" # Let the user override the test with a path.
34512 ;;
34513 *)
34514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34515 for as_dir in $PATH
34516 do
34517 IFS=$as_save_IFS
34518 test -z "$as_dir" && as_dir=.
34519 for ac_exec_ext in '' $ac_executable_extensions; do
34520 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34521 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
34522 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34523 break 2
34524 fi
34525 done
34526 done
34527 IFS=$as_save_IFS
34528
34529 ;;
34530 esac
34531 fi
34532 AS=$ac_cv_path_AS
34533 if test -n "$AS"; then
34534 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
34535 $as_echo "$AS" >&6; }
34536 else
34537 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34538 $as_echo "no" >&6; }
34539 fi
34540
34541
34542 test -n "$AS" && break
34543 done
34544
34545 else
34546 # The variable is set, but is it from the command line or the environment?
34547
34548 # Try to remove the string !AS! from our list.
34549 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AS!/}
34550 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
34551 # If it failed, the variable was not from the command line. Ignore it,
34552 # but warn the user (except for BASH, which is always set by the calling BASH).
34553 if test "xAS" != xBASH; then
34554 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
34555 $as_echo "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
34556 fi
34557 # Try to locate tool using the code snippet
34558 for ac_prog in as
34559 do
34560 # Extract the first word of "$ac_prog", so it can be a program name with args.
34561 set dummy $ac_prog; ac_word=$2
34562 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34563 $as_echo_n "checking for $ac_word... " >&6; }
34564 if ${ac_cv_path_AS+:} false; then :
34565 $as_echo_n "(cached) " >&6
34566 else
34567 case $AS in
34568 [\\/]* | ?:[\\/]*)
34569 ac_cv_path_AS="$AS" # Let the user override the test with a path.
34570 ;;
34571 *)
34572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34573 for as_dir in $PATH
34574 do
34575 IFS=$as_save_IFS
34576 test -z "$as_dir" && as_dir=.
34577 for ac_exec_ext in '' $ac_executable_extensions; do
34578 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34579 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
34580 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34581 break 2
34582 fi
34583 done
34584 done
34585 IFS=$as_save_IFS
34586
34587 ;;
34588 esac
34589 fi
34590 AS=$ac_cv_path_AS
34591 if test -n "$AS"; then
34592 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
34593 $as_echo "$AS" >&6; }
34594 else
34595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34596 $as_echo "no" >&6; }
34597 fi
34598
34599
34600 test -n "$AS" && break
34601 done
34602
34603 else
34604 # If it succeeded, then it was overridden by the user. We will use it
34605 # for the tool.
34606
34607 # First remove it from the list of overridden variables, so we can test
34608 # for unknown variables in the end.
34609 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
34610
34611 # Check if the provided tool contains a complete path.
34612 tool_specified="$AS"
34613 tool_basename="${tool_specified##*/}"
34614 if test "x$tool_basename" = "x$tool_specified"; then
34615 # A command without a complete path is provided, search $PATH.
34616 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
34617 $as_echo "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
34618 # Extract the first word of "$tool_basename", so it can be a program name with args.
34619 set dummy $tool_basename; ac_word=$2
34620 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34621 $as_echo_n "checking for $ac_word... " >&6; }
34622 if ${ac_cv_path_AS+:} false; then :
34623 $as_echo_n "(cached) " >&6
34624 else
34625 case $AS in
34626 [\\/]* | ?:[\\/]*)
34627 ac_cv_path_AS="$AS" # Let the user override the test with a path.
34628 ;;
34629 *)
34630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34631 for as_dir in $PATH
34632 do
34633 IFS=$as_save_IFS
34634 test -z "$as_dir" && as_dir=.
34635 for ac_exec_ext in '' $ac_executable_extensions; do
34636 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34637 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
34638 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34639 break 2
34640 fi
34641 done
34642 done
34643 IFS=$as_save_IFS
34644
34645 ;;
34646 esac
34647 fi
34648 AS=$ac_cv_path_AS
34649 if test -n "$AS"; then
34650 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
34651 $as_echo "$AS" >&6; }
34652 else
34653 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34654 $as_echo "no" >&6; }
34655 fi
34656
34657
34658 if test "x$AS" = x; then
34659 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
34660 fi
34661 else
34662 # Otherwise we believe it is a complete path. Use it as it is.
34663 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
34664 $as_echo "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
34665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
34666 $as_echo_n "checking for AS... " >&6; }
34667 if test ! -x "$tool_specified"; then
34668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
34669 $as_echo "not found" >&6; }
34670 as_fn_error $? "User supplied tool AS=$tool_specified does not exist or is not executable" "$LINENO" 5
34671 fi
34672 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
34673 $as_echo "$tool_specified" >&6; }
34674 fi
34675 fi
34676 fi
34677
34678
34679
34680 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34681
34682 # First separate the path from the arguments. This will split at the first
34683 # space.
34684 complete="$AS"
34685 path="${complete%% *}"
34686 tmp="$complete EOL"
34687 arguments="${tmp#* }"
34688
34689 # Input might be given as Windows format, start by converting to
34690 # unix format.
34691 new_path=`$CYGPATH -u "$path"`
34692
34693 # Now try to locate executable using which
34694 new_path=`$WHICH "$new_path" 2> /dev/null`
34695 # bat and cmd files are not always considered executable in cygwin causing which
34696 # to not find them
34697 if test "x$new_path" = x \
34698 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34931
34932 # Now join together the path and the arguments once again
34933 if test "x$arguments" != xEOL; then
34934 new_complete="$new_path ${arguments% *}"
34935 else
34936 new_complete="$new_path"
34937 fi
34938
34939 if test "x$complete" != "x$new_complete"; then
34940 AS="$new_complete"
34941 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
34942 $as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
34943 fi
34944
34945 else
34946 AS="$CC -c"
34947 fi
34948
34949
34950 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
34951
34952
34953 # Publish this variable in the help.
34954
34955
34956 if test "x$NM" = x; then
34957 # The variable is not set by user, try to locate tool using the code snippet
34958 for ac_prog in nm
34959 do
34960 # Extract the first word of "$ac_prog", so it can be a program name with args.
34961 set dummy $ac_prog; ac_word=$2
34962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34963 $as_echo_n "checking for $ac_word... " >&6; }
34964 if ${ac_cv_path_NM+:} false; then :
34965 $as_echo_n "(cached) " >&6
34966 else
34967 case $NM in
34968 [\\/]* | ?:[\\/]*)
34969 ac_cv_path_NM="$NM" # Let the user override the test with a path.
34970 ;;
34971 *)
34972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34973 for as_dir in $PATH
34974 do
34975 IFS=$as_save_IFS
34976 test -z "$as_dir" && as_dir=.
34977 for ac_exec_ext in '' $ac_executable_extensions; do
34978 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34979 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
34980 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34981 break 2
34982 fi
34983 done
34984 done
34985 IFS=$as_save_IFS
34986
34987 ;;
34988 esac
34989 fi
34990 NM=$ac_cv_path_NM
34991 if test -n "$NM"; then
34992 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
34993 $as_echo "$NM" >&6; }
34994 else
34995 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34996 $as_echo "no" >&6; }
34997 fi
34998
34999
35000 test -n "$NM" && break
35001 done
35002
35003 else
35004 # The variable is set, but is it from the command line or the environment?
35005
35006 # Try to remove the string !NM! from our list.
35007 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
35008 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
35009 # If it failed, the variable was not from the command line. Ignore it,
35010 # but warn the user (except for BASH, which is always set by the calling BASH).
35011 if test "xNM" != xBASH; then
35012 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
35013 $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
35014 fi
35015 # Try to locate tool using the code snippet
35016 for ac_prog in nm
35017 do
35018 # Extract the first word of "$ac_prog", so it can be a program name with args.
35019 set dummy $ac_prog; ac_word=$2
35020 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35021 $as_echo_n "checking for $ac_word... " >&6; }
35022 if ${ac_cv_path_NM+:} false; then :
35023 $as_echo_n "(cached) " >&6
35024 else
35025 case $NM in
35026 [\\/]* | ?:[\\/]*)
35027 ac_cv_path_NM="$NM" # Let the user override the test with a path.
35028 ;;
35029 *)
35030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35031 for as_dir in $PATH
35032 do
35033 IFS=$as_save_IFS
35034 test -z "$as_dir" && as_dir=.
35035 for ac_exec_ext in '' $ac_executable_extensions; do
35036 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35037 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
35038 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35039 break 2
35040 fi
35041 done
35042 done
35043 IFS=$as_save_IFS
35044
35045 ;;
35046 esac
35047 fi
35048 NM=$ac_cv_path_NM
35049 if test -n "$NM"; then
35050 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
35051 $as_echo "$NM" >&6; }
35052 else
35053 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35054 $as_echo "no" >&6; }
35055 fi
35056
35057
35058 test -n "$NM" && break
35059 done
35060
35061 else
35062 # If it succeeded, then it was overridden by the user. We will use it
35063 # for the tool.
35064
35065 # First remove it from the list of overridden variables, so we can test
35066 # for unknown variables in the end.
35067 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
35068
35069 # Check if the provided tool contains a complete path.
35070 tool_specified="$NM"
35071 tool_basename="${tool_specified##*/}"
35072 if test "x$tool_basename" = "x$tool_specified"; then
35073 # A command without a complete path is provided, search $PATH.
35074 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
35075 $as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
35076 # Extract the first word of "$tool_basename", so it can be a program name with args.
35077 set dummy $tool_basename; ac_word=$2
35078 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35079 $as_echo_n "checking for $ac_word... " >&6; }
35080 if ${ac_cv_path_NM+:} false; then :
35081 $as_echo_n "(cached) " >&6
35082 else
35083 case $NM in
35084 [\\/]* | ?:[\\/]*)
35085 ac_cv_path_NM="$NM" # Let the user override the test with a path.
35086 ;;
35087 *)
35088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35089 for as_dir in $PATH
35090 do
35091 IFS=$as_save_IFS
35092 test -z "$as_dir" && as_dir=.
35093 for ac_exec_ext in '' $ac_executable_extensions; do
35094 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35095 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
35096 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35097 break 2
35098 fi
35099 done
35100 done
35101 IFS=$as_save_IFS
35102
35103 ;;
35104 esac
35105 fi
35106 NM=$ac_cv_path_NM
35107 if test -n "$NM"; then
35108 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
35109 $as_echo "$NM" >&6; }
35110 else
35111 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35112 $as_echo "no" >&6; }
35113 fi
35114
35115
35116 if test "x$NM" = x; then
35117 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
35118 fi
35119 else
35120 # Otherwise we believe it is a complete path. Use it as it is.
35121 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
35122 $as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
35123 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
35124 $as_echo_n "checking for NM... " >&6; }
35125 if test ! -x "$tool_specified"; then
35126 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
35127 $as_echo "not found" >&6; }
35128 as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
35129 fi
35130 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
35131 $as_echo "$tool_specified" >&6; }
35132 fi
35133 fi
35134 fi
35135
35136
35137
35138 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35139
35140 # First separate the path from the arguments. This will split at the first
35141 # space.
35142 complete="$NM"
35143 path="${complete%% *}"
35144 tmp="$complete EOL"
35145 arguments="${tmp#* }"
35146
35147 # Input might be given as Windows format, start by converting to
35148 # unix format.
35149 new_path=`$CYGPATH -u "$path"`
35150
35151 # Now try to locate executable using which
35152 new_path=`$WHICH "$new_path" 2> /dev/null`
35153 # bat and cmd files are not always considered executable in cygwin causing which
35154 # to not find them
35155 if test "x$new_path" = x \
35156 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35351 # We're on a posix platform. Hooray! :)
35352 # First separate the path from the arguments. This will split at the first
35353 # space.
35354 complete="$NM"
35355 path="${complete%% *}"
35356 tmp="$complete EOL"
35357 arguments="${tmp#* }"
35358
35359 # Cannot rely on the command "which" here since it doesn't always work.
35360 is_absolute_path=`$ECHO "$path" | $GREP ^/`
35361 if test -z "$is_absolute_path"; then
35362 # Path to executable is not absolute. Find it.
35363 IFS_save="$IFS"
35364 IFS=:
35365 for p in $PATH; do
35366 if test -f "$p/$path" && test -x "$p/$path"; then
35367 new_path="$p/$path"
35368 break
35369 fi
35370 done
35371 IFS="$IFS_save"
35372 else
35373 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving NM (as $path) failed, using $path directly." >&5
35374 $as_echo "$as_me: Resolving NM (as $path) failed, using $path directly." >&6;}
35375 new_path="$path"
35376 fi
35377
35378 if test "x$new_path" = x; then
35379 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
35380 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
35381 has_space=`$ECHO "$complete" | $GREP " "`
35382 if test "x$has_space" != x; then
35383 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
35384 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
35385 fi
35386 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
35387 fi
35388 fi
35389
35390 # Now join together the path and the arguments once again
35391 if test "x$arguments" != xEOL; then
35392 new_complete="$new_path ${arguments% *}"
35393 else
35394 new_complete="$new_path"
35395 fi
35396
35397 if test "x$complete" != "x$new_complete"; then
35398 NM="$new_complete"
35399 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
35400 $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
35401 fi
35402
35403
35404
35405 # Publish this variable in the help.
35406
35407
35408 if test "x$GNM" = x; then
35409 # The variable is not set by user, try to locate tool using the code snippet
35410 for ac_prog in gnm
35411 do
35412 # Extract the first word of "$ac_prog", so it can be a program name with args.
35413 set dummy $ac_prog; ac_word=$2
35414 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35415 $as_echo_n "checking for $ac_word... " >&6; }
35416 if ${ac_cv_path_GNM+:} false; then :
35417 $as_echo_n "(cached) " >&6
35418 else
35419 case $GNM in
35420 [\\/]* | ?:[\\/]*)
35421 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
35422 ;;
35423 *)
35424 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35425 for as_dir in $PATH
35426 do
35427 IFS=$as_save_IFS
35428 test -z "$as_dir" && as_dir=.
35429 for ac_exec_ext in '' $ac_executable_extensions; do
35430 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35431 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
35432 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35433 break 2
35434 fi
35435 done
35436 done
35437 IFS=$as_save_IFS
35438
35439 ;;
35440 esac
35441 fi
35442 GNM=$ac_cv_path_GNM
35443 if test -n "$GNM"; then
35444 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
35445 $as_echo "$GNM" >&6; }
35446 else
35447 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35448 $as_echo "no" >&6; }
35449 fi
35450
35451
35452 test -n "$GNM" && break
35453 done
35454
35455 else
35456 # The variable is set, but is it from the command line or the environment?
35457
35458 # Try to remove the string !GNM! from our list.
35459 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GNM!/}
35460 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
35461 # If it failed, the variable was not from the command line. Ignore it,
35462 # but warn the user (except for BASH, which is always set by the calling BASH).
35463 if test "xGNM" != xBASH; then
35464 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
35465 $as_echo "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
35466 fi
35467 # Try to locate tool using the code snippet
35468 for ac_prog in gnm
35469 do
35470 # Extract the first word of "$ac_prog", so it can be a program name with args.
35471 set dummy $ac_prog; ac_word=$2
35472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35473 $as_echo_n "checking for $ac_word... " >&6; }
35474 if ${ac_cv_path_GNM+:} false; then :
35475 $as_echo_n "(cached) " >&6
35476 else
35477 case $GNM in
35478 [\\/]* | ?:[\\/]*)
35479 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
35480 ;;
35481 *)
35482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35483 for as_dir in $PATH
35484 do
35485 IFS=$as_save_IFS
35486 test -z "$as_dir" && as_dir=.
35487 for ac_exec_ext in '' $ac_executable_extensions; do
35488 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35489 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
35490 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35491 break 2
35492 fi
35493 done
35494 done
35495 IFS=$as_save_IFS
35496
35497 ;;
35498 esac
35499 fi
35500 GNM=$ac_cv_path_GNM
35501 if test -n "$GNM"; then
35502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
35503 $as_echo "$GNM" >&6; }
35504 else
35505 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35506 $as_echo "no" >&6; }
35507 fi
35508
35509
35510 test -n "$GNM" && break
35511 done
35512
35513 else
35514 # If it succeeded, then it was overridden by the user. We will use it
35515 # for the tool.
35516
35517 # First remove it from the list of overridden variables, so we can test
35518 # for unknown variables in the end.
35519 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
35520
35521 # Check if the provided tool contains a complete path.
35522 tool_specified="$GNM"
35523 tool_basename="${tool_specified##*/}"
35524 if test "x$tool_basename" = "x$tool_specified"; then
35525 # A command without a complete path is provided, search $PATH.
35526 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
35527 $as_echo "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
35528 # Extract the first word of "$tool_basename", so it can be a program name with args.
35529 set dummy $tool_basename; ac_word=$2
35530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35531 $as_echo_n "checking for $ac_word... " >&6; }
35532 if ${ac_cv_path_GNM+:} false; then :
35533 $as_echo_n "(cached) " >&6
35534 else
35535 case $GNM in
35536 [\\/]* | ?:[\\/]*)
35537 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
35538 ;;
35539 *)
35540 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35541 for as_dir in $PATH
35542 do
35543 IFS=$as_save_IFS
35544 test -z "$as_dir" && as_dir=.
35545 for ac_exec_ext in '' $ac_executable_extensions; do
35546 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35547 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
35548 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35549 break 2
35550 fi
35551 done
35552 done
35553 IFS=$as_save_IFS
35554
35555 ;;
35556 esac
35557 fi
35558 GNM=$ac_cv_path_GNM
35559 if test -n "$GNM"; then
35560 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
35561 $as_echo "$GNM" >&6; }
35562 else
35563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35564 $as_echo "no" >&6; }
35565 fi
35566
35567
35568 if test "x$GNM" = x; then
35569 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
35570 fi
35571 else
35572 # Otherwise we believe it is a complete path. Use it as it is.
35573 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
35574 $as_echo "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
35575 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
35576 $as_echo_n "checking for GNM... " >&6; }
35577 if test ! -x "$tool_specified"; then
35578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
35579 $as_echo "not found" >&6; }
35580 as_fn_error $? "User supplied tool GNM=$tool_specified does not exist or is not executable" "$LINENO" 5
35581 fi
35582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
35583 $as_echo "$tool_specified" >&6; }
35584 fi
35585 fi
35586 fi
35587
35588
35589
35590 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35591
35592 # First separate the path from the arguments. This will split at the first
35593 # space.
35594 complete="$GNM"
35595 path="${complete%% *}"
35596 tmp="$complete EOL"
35597 arguments="${tmp#* }"
35598
35599 # Input might be given as Windows format, start by converting to
35600 # unix format.
35601 new_path=`$CYGPATH -u "$path"`
35602
35603 # Now try to locate executable using which
35604 new_path=`$WHICH "$new_path" 2> /dev/null`
35605 # bat and cmd files are not always considered executable in cygwin causing which
35606 # to not find them
35607 if test "x$new_path" = x \
35608 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35835 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
35836 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
35837 fi
35838 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
35839 fi
35840 fi
35841
35842 # Now join together the path and the arguments once again
35843 if test "x$arguments" != xEOL; then
35844 new_complete="$new_path ${arguments% *}"
35845 else
35846 new_complete="$new_path"
35847 fi
35848
35849 if test "x$complete" != "x$new_complete"; then
35850 GNM="$new_complete"
35851 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
35852 $as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
35853 fi
35854
35855
35856
35857 # Publish this variable in the help.
35858
35859
35860 if test "x$STRIP" = x; then
35861 # The variable is not set by user, try to locate tool using the code snippet
35862 for ac_prog in strip
35863 do
35864 # Extract the first word of "$ac_prog", so it can be a program name with args.
35865 set dummy $ac_prog; ac_word=$2
35866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35867 $as_echo_n "checking for $ac_word... " >&6; }
35868 if ${ac_cv_path_STRIP+:} false; then :
35869 $as_echo_n "(cached) " >&6
35870 else
35871 case $STRIP in
35872 [\\/]* | ?:[\\/]*)
35873 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
35874 ;;
35875 *)
35876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35877 for as_dir in $PATH
35878 do
35879 IFS=$as_save_IFS
35880 test -z "$as_dir" && as_dir=.
35881 for ac_exec_ext in '' $ac_executable_extensions; do
35882 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35883 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
35884 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35885 break 2
35886 fi
35887 done
35888 done
35889 IFS=$as_save_IFS
35890
35891 ;;
35892 esac
35893 fi
35894 STRIP=$ac_cv_path_STRIP
35895 if test -n "$STRIP"; then
35896 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
35897 $as_echo "$STRIP" >&6; }
35898 else
35899 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35900 $as_echo "no" >&6; }
35901 fi
35902
35903
35904 test -n "$STRIP" && break
35905 done
35906
35907 else
35908 # The variable is set, but is it from the command line or the environment?
35909
35910 # Try to remove the string !STRIP! from our list.
35911 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STRIP!/}
35912 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
35913 # If it failed, the variable was not from the command line. Ignore it,
35914 # but warn the user (except for BASH, which is always set by the calling BASH).
35915 if test "xSTRIP" != xBASH; then
35916 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
35917 $as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
35918 fi
35919 # Try to locate tool using the code snippet
35920 for ac_prog in strip
35921 do
35922 # Extract the first word of "$ac_prog", so it can be a program name with args.
35923 set dummy $ac_prog; ac_word=$2
35924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35925 $as_echo_n "checking for $ac_word... " >&6; }
35926 if ${ac_cv_path_STRIP+:} false; then :
35927 $as_echo_n "(cached) " >&6
35928 else
35929 case $STRIP in
35930 [\\/]* | ?:[\\/]*)
35931 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
35932 ;;
35933 *)
35934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35935 for as_dir in $PATH
35936 do
35937 IFS=$as_save_IFS
35938 test -z "$as_dir" && as_dir=.
35939 for ac_exec_ext in '' $ac_executable_extensions; do
35940 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35941 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
35942 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35943 break 2
35944 fi
35945 done
35946 done
35947 IFS=$as_save_IFS
35948
35949 ;;
35950 esac
35951 fi
35952 STRIP=$ac_cv_path_STRIP
35953 if test -n "$STRIP"; then
35954 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
35955 $as_echo "$STRIP" >&6; }
35956 else
35957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35958 $as_echo "no" >&6; }
35959 fi
35960
35961
35962 test -n "$STRIP" && break
35963 done
35964
35965 else
35966 # If it succeeded, then it was overridden by the user. We will use it
35967 # for the tool.
35968
35969 # First remove it from the list of overridden variables, so we can test
35970 # for unknown variables in the end.
35971 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
35972
35973 # Check if the provided tool contains a complete path.
35974 tool_specified="$STRIP"
35975 tool_basename="${tool_specified##*/}"
35976 if test "x$tool_basename" = "x$tool_specified"; then
35977 # A command without a complete path is provided, search $PATH.
35978 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
35979 $as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
35980 # Extract the first word of "$tool_basename", so it can be a program name with args.
35981 set dummy $tool_basename; ac_word=$2
35982 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35983 $as_echo_n "checking for $ac_word... " >&6; }
35984 if ${ac_cv_path_STRIP+:} false; then :
35985 $as_echo_n "(cached) " >&6
35986 else
35987 case $STRIP in
35988 [\\/]* | ?:[\\/]*)
35989 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
35990 ;;
35991 *)
35992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35993 for as_dir in $PATH
35994 do
35995 IFS=$as_save_IFS
35996 test -z "$as_dir" && as_dir=.
35997 for ac_exec_ext in '' $ac_executable_extensions; do
35998 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35999 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
36000 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36001 break 2
36002 fi
36003 done
36004 done
36005 IFS=$as_save_IFS
36006
36007 ;;
36008 esac
36009 fi
36010 STRIP=$ac_cv_path_STRIP
36011 if test -n "$STRIP"; then
36012 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
36013 $as_echo "$STRIP" >&6; }
36014 else
36015 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36016 $as_echo "no" >&6; }
36017 fi
36018
36019
36020 if test "x$STRIP" = x; then
36021 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
36022 fi
36023 else
36024 # Otherwise we believe it is a complete path. Use it as it is.
36025 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
36026 $as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
36027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
36028 $as_echo_n "checking for STRIP... " >&6; }
36029 if test ! -x "$tool_specified"; then
36030 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
36031 $as_echo "not found" >&6; }
36032 as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
36033 fi
36034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
36035 $as_echo "$tool_specified" >&6; }
36036 fi
36037 fi
36038 fi
36039
36040
36041
36042 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36043
36044 # First separate the path from the arguments. This will split at the first
36045 # space.
36046 complete="$STRIP"
36047 path="${complete%% *}"
36048 tmp="$complete EOL"
36049 arguments="${tmp#* }"
36050
36051 # Input might be given as Windows format, start by converting to
36052 # unix format.
36053 new_path=`$CYGPATH -u "$path"`
36054
36055 # Now try to locate executable using which
36056 new_path=`$WHICH "$new_path" 2> /dev/null`
36057 # bat and cmd files are not always considered executable in cygwin causing which
36058 # to not find them
36059 if test "x$new_path" = x \
36060 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36287 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
36288 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
36289 fi
36290 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
36291 fi
36292 fi
36293
36294 # Now join together the path and the arguments once again
36295 if test "x$arguments" != xEOL; then
36296 new_complete="$new_path ${arguments% *}"
36297 else
36298 new_complete="$new_path"
36299 fi
36300
36301 if test "x$complete" != "x$new_complete"; then
36302 STRIP="$new_complete"
36303 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
36304 $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
36305 fi
36306
36307
36308
36309 # Publish this variable in the help.
36310
36311
36312 if test "x$MCS" = x; then
36313 # The variable is not set by user, try to locate tool using the code snippet
36314 for ac_prog in mcs
36315 do
36316 # Extract the first word of "$ac_prog", so it can be a program name with args.
36317 set dummy $ac_prog; ac_word=$2
36318 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36319 $as_echo_n "checking for $ac_word... " >&6; }
36320 if ${ac_cv_path_MCS+:} false; then :
36321 $as_echo_n "(cached) " >&6
36322 else
36323 case $MCS in
36324 [\\/]* | ?:[\\/]*)
36325 ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
36326 ;;
36327 *)
36328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36329 for as_dir in $PATH
36330 do
36331 IFS=$as_save_IFS
36332 test -z "$as_dir" && as_dir=.
36333 for ac_exec_ext in '' $ac_executable_extensions; do
36334 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36335 ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
36336 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36337 break 2
36338 fi
36339 done
36340 done
36341 IFS=$as_save_IFS
36342
36343 ;;
36344 esac
36345 fi
36346 MCS=$ac_cv_path_MCS
36347 if test -n "$MCS"; then
36348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
36349 $as_echo "$MCS" >&6; }
36350 else
36351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36352 $as_echo "no" >&6; }
36353 fi
36354
36355
36356 test -n "$MCS" && break
36357 done
36358
36359 else
36360 # The variable is set, but is it from the command line or the environment?
36361
36362 # Try to remove the string !MCS! from our list.
36363 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MCS!/}
36364 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
36365 # If it failed, the variable was not from the command line. Ignore it,
36366 # but warn the user (except for BASH, which is always set by the calling BASH).
36367 if test "xMCS" != xBASH; then
36368 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&5
36369 $as_echo "$as_me: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&2;}
36370 fi
36371 # Try to locate tool using the code snippet
36372 for ac_prog in mcs
36373 do
36374 # Extract the first word of "$ac_prog", so it can be a program name with args.
36375 set dummy $ac_prog; ac_word=$2
36376 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36377 $as_echo_n "checking for $ac_word... " >&6; }
36378 if ${ac_cv_path_MCS+:} false; then :
36379 $as_echo_n "(cached) " >&6
36380 else
36381 case $MCS in
36382 [\\/]* | ?:[\\/]*)
36383 ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
36384 ;;
36385 *)
36386 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36387 for as_dir in $PATH
36388 do
36389 IFS=$as_save_IFS
36390 test -z "$as_dir" && as_dir=.
36391 for ac_exec_ext in '' $ac_executable_extensions; do
36392 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36393 ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
36394 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36395 break 2
36396 fi
36397 done
36398 done
36399 IFS=$as_save_IFS
36400
36401 ;;
36402 esac
36403 fi
36404 MCS=$ac_cv_path_MCS
36405 if test -n "$MCS"; then
36406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
36407 $as_echo "$MCS" >&6; }
36408 else
36409 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36410 $as_echo "no" >&6; }
36411 fi
36412
36413
36414 test -n "$MCS" && break
36415 done
36416
36417 else
36418 # If it succeeded, then it was overridden by the user. We will use it
36419 # for the tool.
36420
36421 # First remove it from the list of overridden variables, so we can test
36422 # for unknown variables in the end.
36423 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
36424
36425 # Check if the provided tool contains a complete path.
36426 tool_specified="$MCS"
36427 tool_basename="${tool_specified##*/}"
36428 if test "x$tool_basename" = "x$tool_specified"; then
36429 # A command without a complete path is provided, search $PATH.
36430 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MCS=$tool_basename" >&5
36431 $as_echo "$as_me: Will search for user supplied tool MCS=$tool_basename" >&6;}
36432 # Extract the first word of "$tool_basename", so it can be a program name with args.
36433 set dummy $tool_basename; ac_word=$2
36434 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36435 $as_echo_n "checking for $ac_word... " >&6; }
36436 if ${ac_cv_path_MCS+:} false; then :
36437 $as_echo_n "(cached) " >&6
36438 else
36439 case $MCS in
36440 [\\/]* | ?:[\\/]*)
36441 ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
36442 ;;
36443 *)
36444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36445 for as_dir in $PATH
36446 do
36447 IFS=$as_save_IFS
36448 test -z "$as_dir" && as_dir=.
36449 for ac_exec_ext in '' $ac_executable_extensions; do
36450 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36451 ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
36452 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36453 break 2
36454 fi
36455 done
36456 done
36457 IFS=$as_save_IFS
36458
36459 ;;
36460 esac
36461 fi
36462 MCS=$ac_cv_path_MCS
36463 if test -n "$MCS"; then
36464 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
36465 $as_echo "$MCS" >&6; }
36466 else
36467 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36468 $as_echo "no" >&6; }
36469 fi
36470
36471
36472 if test "x$MCS" = x; then
36473 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
36474 fi
36475 else
36476 # Otherwise we believe it is a complete path. Use it as it is.
36477 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MCS=$tool_specified" >&5
36478 $as_echo "$as_me: Will use user supplied tool MCS=$tool_specified" >&6;}
36479 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MCS" >&5
36480 $as_echo_n "checking for MCS... " >&6; }
36481 if test ! -x "$tool_specified"; then
36482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
36483 $as_echo "not found" >&6; }
36484 as_fn_error $? "User supplied tool MCS=$tool_specified does not exist or is not executable" "$LINENO" 5
36485 fi
36486 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
36487 $as_echo "$tool_specified" >&6; }
36488 fi
36489 fi
36490 fi
36491
36492
36493
36494 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36495
36496 # First separate the path from the arguments. This will split at the first
36497 # space.
36498 complete="$MCS"
36499 path="${complete%% *}"
36500 tmp="$complete EOL"
36501 arguments="${tmp#* }"
36502
36503 # Input might be given as Windows format, start by converting to
36504 # unix format.
36505 new_path=`$CYGPATH -u "$path"`
36506
36507 # Now try to locate executable using which
36508 new_path=`$WHICH "$new_path" 2> /dev/null`
36509 # bat and cmd files are not always considered executable in cygwin causing which
36510 # to not find them
36511 if test "x$new_path" = x \
36512 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36783 done
36784 done
36785 IFS=$as_save_IFS
36786
36787 ;;
36788 esac
36789 fi
36790 OTOOL=$ac_cv_path_OTOOL
36791 if test -n "$OTOOL"; then
36792 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
36793 $as_echo "$OTOOL" >&6; }
36794 else
36795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36796 $as_echo "no" >&6; }
36797 fi
36798
36799
36800 if test "x$OTOOL" = "x"; then
36801 OTOOL="true"
36802 fi
36803
36804
36805 # Publish this variable in the help.
36806
36807
36808 if test "x$NM" = x; then
36809 # The variable is not set by user, try to locate tool using the code snippet
36810 if test -n "$ac_tool_prefix"; then
36811 for ac_prog in nm
36812 do
36813 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
36814 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
36815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36816 $as_echo_n "checking for $ac_word... " >&6; }
36817 if ${ac_cv_prog_NM+:} false; then :
36818 $as_echo_n "(cached) " >&6
36819 else
36820 if test -n "$NM"; then
36821 ac_cv_prog_NM="$NM" # Let the user override the test.
36822 else
36823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36824 for as_dir in $PATH
36825 do
36826 IFS=$as_save_IFS
36827 test -z "$as_dir" && as_dir=.
36828 for ac_exec_ext in '' $ac_executable_extensions; do
36829 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36830 ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
36831 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36832 break 2
36833 fi
36834 done
36835 done
36836 IFS=$as_save_IFS
36837
36838 fi
36839 fi
36840 NM=$ac_cv_prog_NM
36841 if test -n "$NM"; then
36842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
36843 $as_echo "$NM" >&6; }
36844 else
36845 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36846 $as_echo "no" >&6; }
36847 fi
36848
36849
36850 test -n "$NM" && break
36851 done
36852 fi
36853 if test -z "$NM"; then
36854 ac_ct_NM=$NM
36855 for ac_prog in nm
36856 do
36857 # Extract the first word of "$ac_prog", so it can be a program name with args.
36858 set dummy $ac_prog; ac_word=$2
36859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36860 $as_echo_n "checking for $ac_word... " >&6; }
36861 if ${ac_cv_prog_ac_ct_NM+:} false; then :
36862 $as_echo_n "(cached) " >&6
36863 else
36864 if test -n "$ac_ct_NM"; then
36865 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
36866 else
36867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36868 for as_dir in $PATH
36869 do
36870 IFS=$as_save_IFS
36871 test -z "$as_dir" && as_dir=.
36872 for ac_exec_ext in '' $ac_executable_extensions; do
36873 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36874 ac_cv_prog_ac_ct_NM="$ac_prog"
36875 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36876 break 2
36877 fi
36878 done
36879 done
36880 IFS=$as_save_IFS
36881
36882 fi
36883 fi
36884 ac_ct_NM=$ac_cv_prog_ac_ct_NM
36885 if test -n "$ac_ct_NM"; then
36886 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
36887 $as_echo "$ac_ct_NM" >&6; }
36888 else
36889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36890 $as_echo "no" >&6; }
36891 fi
36892
36893
36894 test -n "$ac_ct_NM" && break
36895 done
36896
36897 if test "x$ac_ct_NM" = x; then
36898 NM=""
36899 else
36900 case $cross_compiling:$ac_tool_warned in
36901 yes:)
36902 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
36903 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
36904 ac_tool_warned=yes ;;
36905 esac
36906 NM=$ac_ct_NM
36907 fi
36908 fi
36909
36910 else
36911 # The variable is set, but is it from the command line or the environment?
36912
36913 # Try to remove the string !NM! from our list.
36914 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
36915 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
36916 # If it failed, the variable was not from the command line. Ignore it,
36917 # but warn the user (except for BASH, which is always set by the calling BASH).
36918 if test "xNM" != xBASH; then
36919 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
36920 $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
36921 fi
36922 # Try to locate tool using the code snippet
36923 if test -n "$ac_tool_prefix"; then
36924 for ac_prog in nm
36925 do
36926 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
36927 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
36928 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36929 $as_echo_n "checking for $ac_word... " >&6; }
36930 if ${ac_cv_prog_NM+:} false; then :
36931 $as_echo_n "(cached) " >&6
36932 else
36933 if test -n "$NM"; then
36934 ac_cv_prog_NM="$NM" # Let the user override the test.
36935 else
36936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36937 for as_dir in $PATH
36938 do
36939 IFS=$as_save_IFS
36940 test -z "$as_dir" && as_dir=.
36941 for ac_exec_ext in '' $ac_executable_extensions; do
36942 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36943 ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
36944 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36945 break 2
36946 fi
36947 done
36948 done
36949 IFS=$as_save_IFS
36950
36951 fi
36952 fi
36953 NM=$ac_cv_prog_NM
36954 if test -n "$NM"; then
36955 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
36956 $as_echo "$NM" >&6; }
36957 else
36958 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36959 $as_echo "no" >&6; }
36960 fi
36961
36962
36963 test -n "$NM" && break
36964 done
36965 fi
36966 if test -z "$NM"; then
36967 ac_ct_NM=$NM
36968 for ac_prog in nm
36969 do
36970 # Extract the first word of "$ac_prog", so it can be a program name with args.
36971 set dummy $ac_prog; ac_word=$2
36972 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36973 $as_echo_n "checking for $ac_word... " >&6; }
36974 if ${ac_cv_prog_ac_ct_NM+:} false; then :
36975 $as_echo_n "(cached) " >&6
36976 else
36977 if test -n "$ac_ct_NM"; then
36978 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
36979 else
36980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36981 for as_dir in $PATH
36982 do
36983 IFS=$as_save_IFS
36984 test -z "$as_dir" && as_dir=.
36985 for ac_exec_ext in '' $ac_executable_extensions; do
36986 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36987 ac_cv_prog_ac_ct_NM="$ac_prog"
36988 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36989 break 2
36990 fi
36991 done
36992 done
36993 IFS=$as_save_IFS
36994
36995 fi
36996 fi
36997 ac_ct_NM=$ac_cv_prog_ac_ct_NM
36998 if test -n "$ac_ct_NM"; then
36999 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
37000 $as_echo "$ac_ct_NM" >&6; }
37001 else
37002 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37003 $as_echo "no" >&6; }
37004 fi
37005
37006
37007 test -n "$ac_ct_NM" && break
37008 done
37009
37010 if test "x$ac_ct_NM" = x; then
37011 NM=""
37012 else
37013 case $cross_compiling:$ac_tool_warned in
37014 yes:)
37015 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37016 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37017 ac_tool_warned=yes ;;
37018 esac
37019 NM=$ac_ct_NM
37020 fi
37021 fi
37022
37023 else
37024 # If it succeeded, then it was overridden by the user. We will use it
37025 # for the tool.
37026
37027 # First remove it from the list of overridden variables, so we can test
37028 # for unknown variables in the end.
37029 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
37030
37031 # Check if the provided tool contains a complete path.
37032 tool_specified="$NM"
37033 tool_basename="${tool_specified##*/}"
37034 if test "x$tool_basename" = "x$tool_specified"; then
37035 # A command without a complete path is provided, search $PATH.
37036 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
37037 $as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
37038 # Extract the first word of "$tool_basename", so it can be a program name with args.
37039 set dummy $tool_basename; ac_word=$2
37040 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37041 $as_echo_n "checking for $ac_word... " >&6; }
37042 if ${ac_cv_path_NM+:} false; then :
37043 $as_echo_n "(cached) " >&6
37044 else
37045 case $NM in
37046 [\\/]* | ?:[\\/]*)
37047 ac_cv_path_NM="$NM" # Let the user override the test with a path.
37048 ;;
37049 *)
37050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37051 for as_dir in $PATH
37052 do
37053 IFS=$as_save_IFS
37054 test -z "$as_dir" && as_dir=.
37055 for ac_exec_ext in '' $ac_executable_extensions; do
37056 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37057 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
37058 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37059 break 2
37060 fi
37061 done
37062 done
37063 IFS=$as_save_IFS
37064
37065 ;;
37066 esac
37067 fi
37068 NM=$ac_cv_path_NM
37069 if test -n "$NM"; then
37070 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
37071 $as_echo "$NM" >&6; }
37072 else
37073 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37074 $as_echo "no" >&6; }
37075 fi
37076
37077
37078 if test "x$NM" = x; then
37079 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
37080 fi
37081 else
37082 # Otherwise we believe it is a complete path. Use it as it is.
37083 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
37084 $as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
37085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
37086 $as_echo_n "checking for NM... " >&6; }
37087 if test ! -x "$tool_specified"; then
37088 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
37089 $as_echo "not found" >&6; }
37090 as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
37091 fi
37092 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
37093 $as_echo "$tool_specified" >&6; }
37094 fi
37095 fi
37096 fi
37097
37098
37099
37100 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37101
37102 # First separate the path from the arguments. This will split at the first
37103 # space.
37104 complete="$NM"
37105 path="${complete%% *}"
37106 tmp="$complete EOL"
37107 arguments="${tmp#* }"
37108
37109 # Input might be given as Windows format, start by converting to
37110 # unix format.
37111 new_path=`$CYGPATH -u "$path"`
37112
37113 # Now try to locate executable using which
37114 new_path=`$WHICH "$new_path" 2> /dev/null`
37115 # bat and cmd files are not always considered executable in cygwin causing which
37116 # to not find them
37117 if test "x$new_path" = x \
37118 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37119 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37332 done
37333 IFS="$IFS_save"
37334 else
37335 { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving NM (as $path) failed, using $path directly." >&5
37336 $as_echo "$as_me: Resolving NM (as $path) failed, using $path directly." >&6;}
37337 new_path="$path"
37338 fi
37339
37340 if test "x$new_path" = x; then
37341 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
37342 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
37343 has_space=`$ECHO "$complete" | $GREP " "`
37344 if test "x$has_space" != x; then
37345 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
37346 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
37347 fi
37348 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
37349 fi
37350 fi
37351
37352 # Now join together the path and the arguments once again
37353 if test "x$arguments" != xEOL; then
37354 new_complete="$new_path ${arguments% *}"
37355 else
37356 new_complete="$new_path"
37357 fi
37358
37359 if test "x$complete" != "x$new_complete"; then
37360 NM="$new_complete"
37361 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
37362 $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
37363 fi
37364
37365 GNM="$NM"
37366
37367
37368
37369 # Publish this variable in the help.
37370
37371
37372 if test "x$STRIP" = x; then
37373 # The variable is not set by user, try to locate tool using the code snippet
37374 if test -n "$ac_tool_prefix"; then
37375 for ac_prog in strip
37376 do
37377 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37378 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37379 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37380 $as_echo_n "checking for $ac_word... " >&6; }
37381 if ${ac_cv_prog_STRIP+:} false; then :
37382 $as_echo_n "(cached) " >&6
37383 else
37384 if test -n "$STRIP"; then
37385 ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
37386 else
37387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37388 for as_dir in $PATH
37389 do
37390 IFS=$as_save_IFS
37391 test -z "$as_dir" && as_dir=.
37392 for ac_exec_ext in '' $ac_executable_extensions; do
37393 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37394 ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
37395 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37396 break 2
37397 fi
37398 done
37399 done
37400 IFS=$as_save_IFS
37401
37402 fi
37403 fi
37404 STRIP=$ac_cv_prog_STRIP
37405 if test -n "$STRIP"; then
37406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
37407 $as_echo "$STRIP" >&6; }
37408 else
37409 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37410 $as_echo "no" >&6; }
37411 fi
37412
37413
37414 test -n "$STRIP" && break
37415 done
37416 fi
37417 if test -z "$STRIP"; then
37418 ac_ct_STRIP=$STRIP
37419 for ac_prog in strip
37420 do
37421 # Extract the first word of "$ac_prog", so it can be a program name with args.
37422 set dummy $ac_prog; ac_word=$2
37423 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37424 $as_echo_n "checking for $ac_word... " >&6; }
37425 if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
37426 $as_echo_n "(cached) " >&6
37427 else
37428 if test -n "$ac_ct_STRIP"; then
37429 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
37430 else
37431 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37432 for as_dir in $PATH
37433 do
37434 IFS=$as_save_IFS
37435 test -z "$as_dir" && as_dir=.
37436 for ac_exec_ext in '' $ac_executable_extensions; do
37437 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37438 ac_cv_prog_ac_ct_STRIP="$ac_prog"
37439 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37440 break 2
37441 fi
37442 done
37443 done
37444 IFS=$as_save_IFS
37445
37446 fi
37447 fi
37448 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
37449 if test -n "$ac_ct_STRIP"; then
37450 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
37451 $as_echo "$ac_ct_STRIP" >&6; }
37452 else
37453 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37454 $as_echo "no" >&6; }
37455 fi
37456
37457
37458 test -n "$ac_ct_STRIP" && break
37459 done
37460
37461 if test "x$ac_ct_STRIP" = x; then
37462 STRIP=""
37463 else
37464 case $cross_compiling:$ac_tool_warned in
37465 yes:)
37466 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37467 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37468 ac_tool_warned=yes ;;
37469 esac
37470 STRIP=$ac_ct_STRIP
37471 fi
37472 fi
37473
37474 else
37475 # The variable is set, but is it from the command line or the environment?
37476
37477 # Try to remove the string !STRIP! from our list.
37478 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STRIP!/}
37479 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
37480 # If it failed, the variable was not from the command line. Ignore it,
37481 # but warn the user (except for BASH, which is always set by the calling BASH).
37482 if test "xSTRIP" != xBASH; then
37483 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
37484 $as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
37485 fi
37486 # Try to locate tool using the code snippet
37487 if test -n "$ac_tool_prefix"; then
37488 for ac_prog in strip
37489 do
37490 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37491 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37493 $as_echo_n "checking for $ac_word... " >&6; }
37494 if ${ac_cv_prog_STRIP+:} false; then :
37495 $as_echo_n "(cached) " >&6
37496 else
37497 if test -n "$STRIP"; then
37498 ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
37499 else
37500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37501 for as_dir in $PATH
37502 do
37503 IFS=$as_save_IFS
37504 test -z "$as_dir" && as_dir=.
37505 for ac_exec_ext in '' $ac_executable_extensions; do
37506 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37507 ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
37508 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37509 break 2
37510 fi
37511 done
37512 done
37513 IFS=$as_save_IFS
37514
37515 fi
37516 fi
37517 STRIP=$ac_cv_prog_STRIP
37518 if test -n "$STRIP"; then
37519 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
37520 $as_echo "$STRIP" >&6; }
37521 else
37522 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37523 $as_echo "no" >&6; }
37524 fi
37525
37526
37527 test -n "$STRIP" && break
37528 done
37529 fi
37530 if test -z "$STRIP"; then
37531 ac_ct_STRIP=$STRIP
37532 for ac_prog in strip
37533 do
37534 # Extract the first word of "$ac_prog", so it can be a program name with args.
37535 set dummy $ac_prog; ac_word=$2
37536 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37537 $as_echo_n "checking for $ac_word... " >&6; }
37538 if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
37539 $as_echo_n "(cached) " >&6
37540 else
37541 if test -n "$ac_ct_STRIP"; then
37542 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
37543 else
37544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37545 for as_dir in $PATH
37546 do
37547 IFS=$as_save_IFS
37548 test -z "$as_dir" && as_dir=.
37549 for ac_exec_ext in '' $ac_executable_extensions; do
37550 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37551 ac_cv_prog_ac_ct_STRIP="$ac_prog"
37552 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37553 break 2
37554 fi
37555 done
37556 done
37557 IFS=$as_save_IFS
37558
37559 fi
37560 fi
37561 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
37562 if test -n "$ac_ct_STRIP"; then
37563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
37564 $as_echo "$ac_ct_STRIP" >&6; }
37565 else
37566 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37567 $as_echo "no" >&6; }
37568 fi
37569
37570
37571 test -n "$ac_ct_STRIP" && break
37572 done
37573
37574 if test "x$ac_ct_STRIP" = x; then
37575 STRIP=""
37576 else
37577 case $cross_compiling:$ac_tool_warned in
37578 yes:)
37579 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37580 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37581 ac_tool_warned=yes ;;
37582 esac
37583 STRIP=$ac_ct_STRIP
37584 fi
37585 fi
37586
37587 else
37588 # If it succeeded, then it was overridden by the user. We will use it
37589 # for the tool.
37590
37591 # First remove it from the list of overridden variables, so we can test
37592 # for unknown variables in the end.
37593 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
37594
37595 # Check if the provided tool contains a complete path.
37596 tool_specified="$STRIP"
37597 tool_basename="${tool_specified##*/}"
37598 if test "x$tool_basename" = "x$tool_specified"; then
37599 # A command without a complete path is provided, search $PATH.
37600 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
37601 $as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
37602 # Extract the first word of "$tool_basename", so it can be a program name with args.
37603 set dummy $tool_basename; ac_word=$2
37604 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37605 $as_echo_n "checking for $ac_word... " >&6; }
37606 if ${ac_cv_path_STRIP+:} false; then :
37607 $as_echo_n "(cached) " >&6
37608 else
37609 case $STRIP in
37610 [\\/]* | ?:[\\/]*)
37611 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
37612 ;;
37613 *)
37614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37615 for as_dir in $PATH
37616 do
37617 IFS=$as_save_IFS
37618 test -z "$as_dir" && as_dir=.
37619 for ac_exec_ext in '' $ac_executable_extensions; do
37620 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37621 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
37622 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37623 break 2
37624 fi
37625 done
37626 done
37627 IFS=$as_save_IFS
37628
37629 ;;
37630 esac
37631 fi
37632 STRIP=$ac_cv_path_STRIP
37633 if test -n "$STRIP"; then
37634 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
37635 $as_echo "$STRIP" >&6; }
37636 else
37637 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37638 $as_echo "no" >&6; }
37639 fi
37640
37641
37642 if test "x$STRIP" = x; then
37643 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
37644 fi
37645 else
37646 # Otherwise we believe it is a complete path. Use it as it is.
37647 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
37648 $as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
37649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
37650 $as_echo_n "checking for STRIP... " >&6; }
37651 if test ! -x "$tool_specified"; then
37652 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
37653 $as_echo "not found" >&6; }
37654 as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
37655 fi
37656 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
37657 $as_echo "$tool_specified" >&6; }
37658 fi
37659 fi
37660 fi
37661
37662
37663
37664 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37665
37666 # First separate the path from the arguments. This will split at the first
37667 # space.
37668 complete="$STRIP"
37669 path="${complete%% *}"
37670 tmp="$complete EOL"
37671 arguments="${tmp#* }"
37672
37673 # Input might be given as Windows format, start by converting to
37674 # unix format.
37675 new_path=`$CYGPATH -u "$path"`
37676
37677 # Now try to locate executable using which
37678 new_path=`$WHICH "$new_path" 2> /dev/null`
37679 # bat and cmd files are not always considered executable in cygwin causing which
37680 # to not find them
37681 if test "x$new_path" = x \
37682 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37683 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37914 fi
37915
37916 # Now join together the path and the arguments once again
37917 if test "x$arguments" != xEOL; then
37918 new_complete="$new_path ${arguments% *}"
37919 else
37920 new_complete="$new_path"
37921 fi
37922
37923 if test "x$complete" != "x$new_complete"; then
37924 STRIP="$new_complete"
37925 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
37926 $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
37927 fi
37928
37929 fi
37930
37931 # objcopy is used for moving debug symbols to separate files when
37932 # full debug symbols are enabled.
37933 if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
37934
37935
37936 # Publish this variable in the help.
37937
37938
37939 if test "x$OBJCOPY" = x; then
37940 # The variable is not set by user, try to locate tool using the code snippet
37941 if test -n "$ac_tool_prefix"; then
37942 for ac_prog in gobjcopy objcopy
37943 do
37944 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37945 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37947 $as_echo_n "checking for $ac_word... " >&6; }
37948 if ${ac_cv_prog_OBJCOPY+:} false; then :
37949 $as_echo_n "(cached) " >&6
37950 else
37951 if test -n "$OBJCOPY"; then
37952 ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
37953 else
37954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37955 for as_dir in $PATH
37956 do
37957 IFS=$as_save_IFS
37958 test -z "$as_dir" && as_dir=.
37959 for ac_exec_ext in '' $ac_executable_extensions; do
37960 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37961 ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
37962 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37963 break 2
37964 fi
37965 done
37966 done
37967 IFS=$as_save_IFS
37968
37969 fi
37970 fi
37971 OBJCOPY=$ac_cv_prog_OBJCOPY
37972 if test -n "$OBJCOPY"; then
37973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
37974 $as_echo "$OBJCOPY" >&6; }
37975 else
37976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37977 $as_echo "no" >&6; }
37978 fi
37979
37980
37981 test -n "$OBJCOPY" && break
37982 done
37983 fi
37984 if test -z "$OBJCOPY"; then
37985 ac_ct_OBJCOPY=$OBJCOPY
37986 for ac_prog in gobjcopy objcopy
37987 do
37988 # Extract the first word of "$ac_prog", so it can be a program name with args.
37989 set dummy $ac_prog; ac_word=$2
37990 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37991 $as_echo_n "checking for $ac_word... " >&6; }
37992 if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
37993 $as_echo_n "(cached) " >&6
37994 else
37995 if test -n "$ac_ct_OBJCOPY"; then
37996 ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
37997 else
37998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37999 for as_dir in $PATH
38000 do
38001 IFS=$as_save_IFS
38002 test -z "$as_dir" && as_dir=.
38003 for ac_exec_ext in '' $ac_executable_extensions; do
38004 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38005 ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
38006 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38007 break 2
38008 fi
38009 done
38010 done
38011 IFS=$as_save_IFS
38012
38013 fi
38014 fi
38015 ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
38016 if test -n "$ac_ct_OBJCOPY"; then
38017 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
38018 $as_echo "$ac_ct_OBJCOPY" >&6; }
38019 else
38020 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38021 $as_echo "no" >&6; }
38022 fi
38023
38024
38025 test -n "$ac_ct_OBJCOPY" && break
38026 done
38027
38028 if test "x$ac_ct_OBJCOPY" = x; then
38029 OBJCOPY=""
38030 else
38031 case $cross_compiling:$ac_tool_warned in
38032 yes:)
38033 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
38034 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
38035 ac_tool_warned=yes ;;
38036 esac
38037 OBJCOPY=$ac_ct_OBJCOPY
38038 fi
38039 fi
38040
38041 else
38042 # The variable is set, but is it from the command line or the environment?
38043
38044 # Try to remove the string !OBJCOPY! from our list.
38045 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OBJCOPY!/}
38046 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
38047 # If it failed, the variable was not from the command line. Ignore it,
38048 # but warn the user (except for BASH, which is always set by the calling BASH).
38049 if test "xOBJCOPY" != xBASH; then
38050 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
38051 $as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
38052 fi
38053 # Try to locate tool using the code snippet
38054 if test -n "$ac_tool_prefix"; then
38055 for ac_prog in gobjcopy objcopy
38056 do
38057 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
38058 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
38059 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38060 $as_echo_n "checking for $ac_word... " >&6; }
38061 if ${ac_cv_prog_OBJCOPY+:} false; then :
38062 $as_echo_n "(cached) " >&6
38063 else
38064 if test -n "$OBJCOPY"; then
38065 ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
38066 else
38067 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38068 for as_dir in $PATH
38069 do
38070 IFS=$as_save_IFS
38071 test -z "$as_dir" && as_dir=.
38072 for ac_exec_ext in '' $ac_executable_extensions; do
38073 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38134 $as_echo "no" >&6; }
38135 fi
38136
38137
38138 test -n "$ac_ct_OBJCOPY" && break
38139 done
38140
38141 if test "x$ac_ct_OBJCOPY" = x; then
38142 OBJCOPY=""
38143 else
38144 case $cross_compiling:$ac_tool_warned in
38145 yes:)
38146 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
38147 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
38148 ac_tool_warned=yes ;;
38149 esac
38150 OBJCOPY=$ac_ct_OBJCOPY
38151 fi
38152 fi
38153
38154 else
38155 # If it succeeded, then it was overridden by the user. We will use it
38156 # for the tool.
38157
38158 # First remove it from the list of overridden variables, so we can test
38159 # for unknown variables in the end.
38160 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
38161
38162 # Check if the provided tool contains a complete path.
38163 tool_specified="$OBJCOPY"
38164 tool_basename="${tool_specified##*/}"
38165 if test "x$tool_basename" = "x$tool_specified"; then
38166 # A command without a complete path is provided, search $PATH.
38167 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
38168 $as_echo "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
38169 # Extract the first word of "$tool_basename", so it can be a program name with args.
38170 set dummy $tool_basename; ac_word=$2
38171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38172 $as_echo_n "checking for $ac_word... " >&6; }
38173 if ${ac_cv_path_OBJCOPY+:} false; then :
38174 $as_echo_n "(cached) " >&6
38175 else
38176 case $OBJCOPY in
38177 [\\/]* | ?:[\\/]*)
38178 ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path.
38179 ;;
38180 *)
38181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38182 for as_dir in $PATH
38183 do
38184 IFS=$as_save_IFS
38185 test -z "$as_dir" && as_dir=.
38186 for ac_exec_ext in '' $ac_executable_extensions; do
38187 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38188 ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
38189 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38190 break 2
38191 fi
38192 done
38193 done
38194 IFS=$as_save_IFS
38195
38196 ;;
38197 esac
38198 fi
38199 OBJCOPY=$ac_cv_path_OBJCOPY
38200 if test -n "$OBJCOPY"; then
38201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
38202 $as_echo "$OBJCOPY" >&6; }
38203 else
38204 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38205 $as_echo "no" >&6; }
38206 fi
38207
38208
38209 if test "x$OBJCOPY" = x; then
38210 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
38211 fi
38212 else
38213 # Otherwise we believe it is a complete path. Use it as it is.
38214 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
38215 $as_echo "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
38216 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
38217 $as_echo_n "checking for OBJCOPY... " >&6; }
38218 if test ! -x "$tool_specified"; then
38219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
38220 $as_echo "not found" >&6; }
38221 as_fn_error $? "User supplied tool OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
38222 fi
38223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
38224 $as_echo "$tool_specified" >&6; }
38225 fi
38226 fi
38227 fi
38228
38229
38230 # Only call fixup if objcopy was found.
38231 if test -n "$OBJCOPY"; then
38232
38233 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38234
38235 # First separate the path from the arguments. This will split at the first
38236 # space.
38237 complete="$OBJCOPY"
38238 path="${complete%% *}"
38239 tmp="$complete EOL"
38240 arguments="${tmp#* }"
38241
38242 # Input might be given as Windows format, start by converting to
38243 # unix format.
38244 new_path=`$CYGPATH -u "$path"`
38245
38246 # Now try to locate executable using which
38247 new_path=`$WHICH "$new_path" 2> /dev/null`
38248 # bat and cmd files are not always considered executable in cygwin causing which
38249 # to not find them
38481 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
38482 fi
38483 fi
38484
38485 # Now join together the path and the arguments once again
38486 if test "x$arguments" != xEOL; then
38487 new_complete="$new_path ${arguments% *}"
38488 else
38489 new_complete="$new_path"
38490 fi
38491
38492 if test "x$complete" != "x$new_complete"; then
38493 OBJCOPY="$new_complete"
38494 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
38495 $as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
38496 fi
38497
38498 fi
38499 fi
38500
38501
38502
38503 # Publish this variable in the help.
38504
38505
38506 if test "x$OBJDUMP" = x; then
38507 # The variable is not set by user, try to locate tool using the code snippet
38508 if test -n "$ac_tool_prefix"; then
38509 for ac_prog in gobjdump objdump
38510 do
38511 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
38512 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
38513 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38514 $as_echo_n "checking for $ac_word... " >&6; }
38515 if ${ac_cv_prog_OBJDUMP+:} false; then :
38516 $as_echo_n "(cached) " >&6
38517 else
38518 if test -n "$OBJDUMP"; then
38519 ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
38520 else
38521 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38522 for as_dir in $PATH
38523 do
38524 IFS=$as_save_IFS
38525 test -z "$as_dir" && as_dir=.
38526 for ac_exec_ext in '' $ac_executable_extensions; do
38527 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38528 ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
38529 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38530 break 2
38531 fi
38532 done
38533 done
38534 IFS=$as_save_IFS
38535
38536 fi
38537 fi
38538 OBJDUMP=$ac_cv_prog_OBJDUMP
38539 if test -n "$OBJDUMP"; then
38540 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
38541 $as_echo "$OBJDUMP" >&6; }
38542 else
38543 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38544 $as_echo "no" >&6; }
38545 fi
38546
38547
38548 test -n "$OBJDUMP" && break
38549 done
38550 fi
38551 if test -z "$OBJDUMP"; then
38552 ac_ct_OBJDUMP=$OBJDUMP
38553 for ac_prog in gobjdump objdump
38554 do
38555 # Extract the first word of "$ac_prog", so it can be a program name with args.
38556 set dummy $ac_prog; ac_word=$2
38557 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38558 $as_echo_n "checking for $ac_word... " >&6; }
38559 if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
38560 $as_echo_n "(cached) " >&6
38561 else
38562 if test -n "$ac_ct_OBJDUMP"; then
38563 ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
38564 else
38565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38566 for as_dir in $PATH
38567 do
38568 IFS=$as_save_IFS
38569 test -z "$as_dir" && as_dir=.
38570 for ac_exec_ext in '' $ac_executable_extensions; do
38571 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38572 ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
38573 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38574 break 2
38575 fi
38576 done
38577 done
38578 IFS=$as_save_IFS
38579
38580 fi
38581 fi
38582 ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
38583 if test -n "$ac_ct_OBJDUMP"; then
38584 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
38585 $as_echo "$ac_ct_OBJDUMP" >&6; }
38586 else
38587 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38588 $as_echo "no" >&6; }
38589 fi
38590
38591
38592 test -n "$ac_ct_OBJDUMP" && break
38593 done
38594
38595 if test "x$ac_ct_OBJDUMP" = x; then
38596 OBJDUMP=""
38597 else
38598 case $cross_compiling:$ac_tool_warned in
38599 yes:)
38600 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
38601 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
38602 ac_tool_warned=yes ;;
38603 esac
38604 OBJDUMP=$ac_ct_OBJDUMP
38605 fi
38606 fi
38607
38608 else
38609 # The variable is set, but is it from the command line or the environment?
38610
38611 # Try to remove the string !OBJDUMP! from our list.
38612 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OBJDUMP!/}
38613 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
38614 # If it failed, the variable was not from the command line. Ignore it,
38615 # but warn the user (except for BASH, which is always set by the calling BASH).
38616 if test "xOBJDUMP" != xBASH; then
38617 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
38618 $as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
38619 fi
38620 # Try to locate tool using the code snippet
38621 if test -n "$ac_tool_prefix"; then
38622 for ac_prog in gobjdump objdump
38623 do
38624 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
38625 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
38626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38627 $as_echo_n "checking for $ac_word... " >&6; }
38628 if ${ac_cv_prog_OBJDUMP+:} false; then :
38629 $as_echo_n "(cached) " >&6
38630 else
38631 if test -n "$OBJDUMP"; then
38632 ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
38633 else
38634 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38635 for as_dir in $PATH
38636 do
38637 IFS=$as_save_IFS
38638 test -z "$as_dir" && as_dir=.
38639 for ac_exec_ext in '' $ac_executable_extensions; do
38640 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38701 $as_echo "no" >&6; }
38702 fi
38703
38704
38705 test -n "$ac_ct_OBJDUMP" && break
38706 done
38707
38708 if test "x$ac_ct_OBJDUMP" = x; then
38709 OBJDUMP=""
38710 else
38711 case $cross_compiling:$ac_tool_warned in
38712 yes:)
38713 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
38714 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
38715 ac_tool_warned=yes ;;
38716 esac
38717 OBJDUMP=$ac_ct_OBJDUMP
38718 fi
38719 fi
38720
38721 else
38722 # If it succeeded, then it was overridden by the user. We will use it
38723 # for the tool.
38724
38725 # First remove it from the list of overridden variables, so we can test
38726 # for unknown variables in the end.
38727 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
38728
38729 # Check if the provided tool contains a complete path.
38730 tool_specified="$OBJDUMP"
38731 tool_basename="${tool_specified##*/}"
38732 if test "x$tool_basename" = "x$tool_specified"; then
38733 # A command without a complete path is provided, search $PATH.
38734 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
38735 $as_echo "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
38736 # Extract the first word of "$tool_basename", so it can be a program name with args.
38737 set dummy $tool_basename; ac_word=$2
38738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38739 $as_echo_n "checking for $ac_word... " >&6; }
38740 if ${ac_cv_path_OBJDUMP+:} false; then :
38741 $as_echo_n "(cached) " >&6
38742 else
38743 case $OBJDUMP in
38744 [\\/]* | ?:[\\/]*)
38745 ac_cv_path_OBJDUMP="$OBJDUMP" # Let the user override the test with a path.
38746 ;;
38747 *)
38748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38749 for as_dir in $PATH
38750 do
38751 IFS=$as_save_IFS
38752 test -z "$as_dir" && as_dir=.
38753 for ac_exec_ext in '' $ac_executable_extensions; do
38754 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38755 ac_cv_path_OBJDUMP="$as_dir/$ac_word$ac_exec_ext"
38756 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38757 break 2
38758 fi
38759 done
38760 done
38761 IFS=$as_save_IFS
38762
38763 ;;
38764 esac
38765 fi
38766 OBJDUMP=$ac_cv_path_OBJDUMP
38767 if test -n "$OBJDUMP"; then
38768 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
38769 $as_echo "$OBJDUMP" >&6; }
38770 else
38771 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38772 $as_echo "no" >&6; }
38773 fi
38774
38775
38776 if test "x$OBJDUMP" = x; then
38777 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
38778 fi
38779 else
38780 # Otherwise we believe it is a complete path. Use it as it is.
38781 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
38782 $as_echo "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
38783 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
38784 $as_echo_n "checking for OBJDUMP... " >&6; }
38785 if test ! -x "$tool_specified"; then
38786 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
38787 $as_echo "not found" >&6; }
38788 as_fn_error $? "User supplied tool OBJDUMP=$tool_specified does not exist or is not executable" "$LINENO" 5
38789 fi
38790 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
38791 $as_echo "$tool_specified" >&6; }
38792 fi
38793 fi
38794 fi
38795
38796
38797 if test "x$OBJDUMP" != x; then
38798 # Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE bails if argument is missing.
38799
38800 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38801
38802 # First separate the path from the arguments. This will split at the first
38803 # space.
38804 complete="$OBJDUMP"
38805 path="${complete%% *}"
38806 tmp="$complete EOL"
38807 arguments="${tmp#* }"
38808
38809 # Input might be given as Windows format, start by converting to
38810 # unix format.
38811 new_path=`$CYGPATH -u "$path"`
38812
38813 # Now try to locate executable using which
38814 new_path=`$WHICH "$new_path" 2> /dev/null`
38815 # bat and cmd files are not always considered executable in cygwin causing which
38816 # to not find them
46687 # Setup use of ccache, if available
46688
46689 # Check whether --enable-ccache was given.
46690 if test "${enable_ccache+set}" = set; then :
46691 enableval=$enable_ccache;
46692 fi
46693
46694
46695 CCACHE=
46696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
46697 $as_echo_n "checking is ccache enabled... " >&6; }
46698 ENABLE_CCACHE=$enable_ccache
46699 if test "x$enable_ccache" = xyes; then
46700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
46701 $as_echo "yes" >&6; }
46702 OLD_PATH="$PATH"
46703 if test "x$TOOLS_DIR" != x; then
46704 PATH=$TOOLS_DIR:$PATH
46705 fi
46706
46707
46708
46709 # Publish this variable in the help.
46710
46711
46712 if test "x$CCACHE" = x; then
46713 # The variable is not set by user, try to locate tool using the code snippet
46714 for ac_prog in ccache
46715 do
46716 # Extract the first word of "$ac_prog", so it can be a program name with args.
46717 set dummy $ac_prog; ac_word=$2
46718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46719 $as_echo_n "checking for $ac_word... " >&6; }
46720 if ${ac_cv_path_CCACHE+:} false; then :
46721 $as_echo_n "(cached) " >&6
46722 else
46723 case $CCACHE in
46724 [\\/]* | ?:[\\/]*)
46725 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
46726 ;;
46727 *)
46728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46729 for as_dir in $PATH
46730 do
46731 IFS=$as_save_IFS
46732 test -z "$as_dir" && as_dir=.
46733 for ac_exec_ext in '' $ac_executable_extensions; do
46734 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46735 ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
46736 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46737 break 2
46738 fi
46739 done
46740 done
46741 IFS=$as_save_IFS
46742
46743 ;;
46744 esac
46745 fi
46746 CCACHE=$ac_cv_path_CCACHE
46747 if test -n "$CCACHE"; then
46748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
46749 $as_echo "$CCACHE" >&6; }
46750 else
46751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46752 $as_echo "no" >&6; }
46753 fi
46754
46755
46756 test -n "$CCACHE" && break
46757 done
46758
46759 else
46760 # The variable is set, but is it from the command line or the environment?
46761
46762 # Try to remove the string !CCACHE! from our list.
46763 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CCACHE!/}
46764 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
46765 # If it failed, the variable was not from the command line. Ignore it,
46766 # but warn the user (except for BASH, which is always set by the calling BASH).
46767 if test "xCCACHE" != xBASH; then
46768 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
46769 $as_echo "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
46770 fi
46771 # Try to locate tool using the code snippet
46772 for ac_prog in ccache
46773 do
46774 # Extract the first word of "$ac_prog", so it can be a program name with args.
46775 set dummy $ac_prog; ac_word=$2
46776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46777 $as_echo_n "checking for $ac_word... " >&6; }
46778 if ${ac_cv_path_CCACHE+:} false; then :
46779 $as_echo_n "(cached) " >&6
46780 else
46781 case $CCACHE in
46782 [\\/]* | ?:[\\/]*)
46783 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
46784 ;;
46785 *)
46786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46787 for as_dir in $PATH
46788 do
46789 IFS=$as_save_IFS
46790 test -z "$as_dir" && as_dir=.
46791 for ac_exec_ext in '' $ac_executable_extensions; do
46797 done
46798 done
46799 IFS=$as_save_IFS
46800
46801 ;;
46802 esac
46803 fi
46804 CCACHE=$ac_cv_path_CCACHE
46805 if test -n "$CCACHE"; then
46806 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
46807 $as_echo "$CCACHE" >&6; }
46808 else
46809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46810 $as_echo "no" >&6; }
46811 fi
46812
46813
46814 test -n "$CCACHE" && break
46815 done
46816
46817 else
46818 # If it succeeded, then it was overridden by the user. We will use it
46819 # for the tool.
46820
46821 # First remove it from the list of overridden variables, so we can test
46822 # for unknown variables in the end.
46823 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
46824
46825 # Check if the provided tool contains a complete path.
46826 tool_specified="$CCACHE"
46827 tool_basename="${tool_specified##*/}"
46828 if test "x$tool_basename" = "x$tool_specified"; then
46829 # A command without a complete path is provided, search $PATH.
46830 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
46831 $as_echo "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
46832 # Extract the first word of "$tool_basename", so it can be a program name with args.
46833 set dummy $tool_basename; ac_word=$2
46834 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46835 $as_echo_n "checking for $ac_word... " >&6; }
46836 if ${ac_cv_path_CCACHE+:} false; then :
46837 $as_echo_n "(cached) " >&6
46838 else
46839 case $CCACHE in
46840 [\\/]* | ?:[\\/]*)
46841 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
46842 ;;
46843 *)
46844 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46845 for as_dir in $PATH
46846 do
46847 IFS=$as_save_IFS
46848 test -z "$as_dir" && as_dir=.
46849 for ac_exec_ext in '' $ac_executable_extensions; do
46850 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46851 ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
46852 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46853 break 2
46854 fi
46855 done
46856 done
46857 IFS=$as_save_IFS
46858
46859 ;;
46860 esac
46861 fi
46862 CCACHE=$ac_cv_path_CCACHE
46863 if test -n "$CCACHE"; then
46864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
46865 $as_echo "$CCACHE" >&6; }
46866 else
46867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46868 $as_echo "no" >&6; }
46869 fi
46870
46871
46872 if test "x$CCACHE" = x; then
46873 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
46874 fi
46875 else
46876 # Otherwise we believe it is a complete path. Use it as it is.
46877 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
46878 $as_echo "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
46879 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
46880 $as_echo_n "checking for CCACHE... " >&6; }
46881 if test ! -x "$tool_specified"; then
46882 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
46883 $as_echo "not found" >&6; }
46884 as_fn_error $? "User supplied tool CCACHE=$tool_specified does not exist or is not executable" "$LINENO" 5
46885 fi
46886 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
46887 $as_echo "$tool_specified" >&6; }
46888 fi
46889 fi
46890 fi
46891
46892
46893
46894 if test "x$CCACHE" = x; then
46895 as_fn_error $? "Could not find required tool for CCACHE" "$LINENO" 5
46896 fi
46897
46898
46899 CCACHE_STATUS="enabled"
46900 PATH="$OLD_PATH"
46901 elif test "x$enable_ccache" = xno; then
46902 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
46903 $as_echo "no, explicitly disabled" >&6; }
46904 elif test "x$enable_ccache" = x; then
46905 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46906 $as_echo "no" >&6; }
46907 else
46908 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
46909 $as_echo "unknown" >&6; }
46910 as_fn_error $? "--enable-ccache does not accept any parameters" "$LINENO" 5
46911 fi
46912
46913
46914
46915 # Check whether --with-ccache-dir was given.
46988 chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1
46989 fi
46990 fi
46991
46992 fi
46993
46994
46995 ###############################################################################
46996 #
46997 # And now the finish...
46998 #
46999 ###############################################################################
47000
47001 # Check for some common pitfalls
47002
47003 if test x"$OPENJDK_BUILD_OS" = xwindows; then
47004 file_to_test="$SRC_ROOT/LICENSE"
47005 if test `$STAT -c '%a' "$file_to_test"` -lt 400; then
47006 as_fn_error $? "Bad file permissions on src files. This is usually caused by cloning the repositories with a non cygwin hg in a directory not created in cygwin." "$LINENO" 5
47007 fi
47008 fi
47009
47010
47011 # Did user specify any unknown variables?
47012
47013 if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
47014 # Replace the separating ! with spaces before presenting for end user.
47015 unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
47016 as_fn_error $? "The following variables are unknown to configure: $unknown_variables" "$LINENO" 5
47017 fi
47018
47019
47020 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
47021 $as_echo_n "checking if build directory is on local disk... " >&6; }
47022
47023 # df -l lists only local disks; if the given directory is not found then
47024 # a non-zero exit code is given
47025 if test "x$DF" = x; then
47026 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47027 # msys does not have df; use Windows "net use" instead.
47028 IS_NETWORK_DISK=`net use | grep \`pwd -W | cut -d ":" -f 1 | tr a-z A-Z\`:`
47029 if test "x$IS_NETWORK_DISK" = x; then
47030 OUTPUT_DIR_IS_LOCAL="yes"
47031 else
47032 OUTPUT_DIR_IS_LOCAL="no"
47033 fi
47034 else
47035 # No df here, say it's local
47036 OUTPUT_DIR_IS_LOCAL="yes"
|