jdk8-mips64-public: comparison common/autoconf/generated-configure.sh

-:e20ffc02e437
+:ed9e5635fc80
 # definitions. It is replaced with custom functionality when building
 # custom sources.
 #CUSTOM_AUTOCONF_INCLUDE
 # Do not change or remove the following line, it is needed for consistency checks:
-DATE_WHEN_GENERATED=1351539315
+DATE_WHEN_GENERATED=1351854415
 ###############################################################################
 #
 # Initialization / Boot-strapping
 #
 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
 # other files
 files_present=`$LS $OUTPUT_ROOT`
-if test "x$files_present" != x; then
+# Configure has already touched config.log and confdefs.h in the current dir when this check
+# is performed.
+filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
+| $TR -d '\n'`
+if test "x$filtered_files" != x; then
 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of WINLD, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of WINLD, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of WINAR, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of WINAR, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 # unix format.
 new_path=`$CYGPATH -u "$path"`
 # Now try to locate executable using which
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # Oops. Which didn't find the executable.
 # The splitting of arguments from the executable at a space might have been incorrect,
 # since paths with space are more likely in Windows. Give it another try with the whole
 # argument.
 path="$complete"
 arguments="EOL"
 new_path=`$CYGPATH -u "$path"`
 new_path=`$WHICH "$new_path" 2> /dev/null`
+# bat and cmd files are not always considered executable in cygwin causing which
+# to not find them
+if test "x$new_path" = x \
+&& test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
+&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
+new_path=`$CYGPATH -u "$path"`
+fi
 if test "x$new_path" = x; then
 # It's still not found. Now this is an unrecoverable error.
 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
 $as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
 has_space=`$ECHO "$complete" | $GREP " "`
 LIBS=$ac_check_lib_save_LIBS
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_freetype_FT_Init_FreeType" >&5
 $as_echo "$ac_cv_lib_freetype_FT_Init_FreeType" >&6; }
 if test "x$ac_cv_lib_freetype_FT_Init_FreeType" = x""yes; then :
-cat >>confdefs.h <<_ACEOF
+FREETYPE2_FOUND=true
-#define HAVE_LIBFREETYPE 1
-_ACEOF
-LIBS="-lfreetype $LIBS"
 else
 as_fn_error $? "Could not find freetype2! $HELP_MSG " "$LINENO" 5
 fi
 LDFLAGS="$PREV_LDFLAGS"

Mercurial > jdk8-mips64-public / file comparison

comparison: common/autoconf/generated-configure.sh

common/autoconf/generated-configure.sh