Mercurial > jdk8-mips64-public / changeset

     1.1 --- a/common/autoconf/basics.m4	Sat Nov 03 16:15:26 2012 -0700
     1.2 +++ b/common/autoconf/basics.m4	Sat Nov 03 16:28:14 2012 -0700
     1.3 @@ -373,7 +373,11 @@
     1.4        # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
     1.5        # other files
     1.6        files_present=`$LS $OUTPUT_ROOT`
     1.7 -      if test "x$files_present" != x; then
     1.8 +      # Configure has already touched config.log and confdefs.h in the current dir when this check 
     1.9 +      # is performed.
    1.10 +      filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
    1.11 +                                             | $TR -d '\n'`
    1.12 +      if test "x$filtered_files" != x; then
    1.13          AC_MSG_NOTICE([Current directory is $CURDIR.])
    1.14          AC_MSG_NOTICE([Since this is not the source root, configure will output the configuration here])
    1.15          AC_MSG_NOTICE([(as opposed to creating a configuration in <src_root>/build/<conf-name>).])

     2.1 --- a/common/autoconf/basics_windows.m4	Sat Nov 03 16:15:26 2012 -0700
     2.2 +++ b/common/autoconf/basics_windows.m4	Sat Nov 03 16:28:14 2012 -0700
     2.3 @@ -172,6 +172,13 @@
     2.4  
     2.5    # Now try to locate executable using which
     2.6    new_path=`$WHICH "$new_path" 2> /dev/null`
     2.7 +  # bat and cmd files are not always considered executable in cygwin causing which
     2.8 +  # to not find them
     2.9 +  if test "x$new_path" = x \
    2.10 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
    2.11 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
    2.12 +    new_path=`$CYGPATH -u "$path"`
    2.13 +  fi
    2.14    if test "x$new_path" = x; then
    2.15      # Oops. Which didn't find the executable.
    2.16      # The splitting of arguments from the executable at a space might have been incorrect,
    2.17 @@ -181,6 +188,13 @@
    2.18      arguments="EOL"
    2.19      new_path=`$CYGPATH -u "$path"`
    2.20      new_path=`$WHICH "$new_path" 2> /dev/null`
    2.21 +    # bat and cmd files are not always considered executable in cygwin causing which
    2.22 +    # to not find them
    2.23 +    if test "x$new_path" = x \
    2.24 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
    2.25 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
    2.26 +      new_path=`$CYGPATH -u "$path"`
    2.27 +    fi
    2.28      if test "x$new_path" = x; then
    2.29        # It's still not found. Now this is an unrecoverable error.
    2.30        AC_MSG_NOTICE([The path of $1, which resolves as "$complete", is not found.])

     3.1 --- a/common/autoconf/compare.sh.in	Sat Nov 03 16:15:26 2012 -0700
     3.2 +++ b/common/autoconf/compare.sh.in	Sat Nov 03 16:28:14 2012 -0700
     3.3 @@ -60,6 +60,7 @@
     3.4  STRIP="@POST_STRIP_CMD@"
     3.5  TEE="@TEE@"
     3.6  UNIQ="@UNIQ@"
     3.7 +UNPACK200="@FIXPATH@ @BOOT_JDK@/bin/unpack200"
     3.8  UNZIP="@UNZIP@"
     3.9  
    3.10  SRC_ROOT="@SRC_ROOT@"

     4.1 --- a/common/autoconf/generated-configure.sh	Sat Nov 03 16:15:26 2012 -0700
     4.2 +++ b/common/autoconf/generated-configure.sh	Sat Nov 03 16:28:14 2012 -0700
     4.3 @@ -3665,7 +3665,7 @@
     4.4  #CUSTOM_AUTOCONF_INCLUDE
     4.5  
     4.6  # Do not change or remove the following line, it is needed for consistency checks:
     4.7 -DATE_WHEN_GENERATED=1351539315
     4.8 +DATE_WHEN_GENERATED=1351854415
     4.9  
    4.10  ###############################################################################
    4.11  #
    4.12 @@ -7603,7 +7603,11 @@
    4.13        # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
    4.14        # other files
    4.15        files_present=`$LS $OUTPUT_ROOT`
    4.16 -      if test "x$files_present" != x; then
    4.17 +      # Configure has already touched config.log and confdefs.h in the current dir when this check
    4.18 +      # is performed.
    4.19 +      filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
    4.20 +                                             | $TR -d '\n'`
    4.21 +      if test "x$filtered_files" != x; then
    4.22          { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
    4.23  $as_echo "$as_me: Current directory is $CURDIR." >&6;}
    4.24          { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
    4.25 @@ -7889,15 +7893,29 @@
    4.26  
    4.27    # Now try to locate executable using which
    4.28    new_path=`$WHICH "$new_path" 2> /dev/null`
    4.29 -  if test "x$new_path" = x; then
    4.30 -    # Oops. Which didn't find the executable.
    4.31 -    # The splitting of arguments from the executable at a space might have been incorrect,
    4.32 -    # since paths with space are more likely in Windows. Give it another try with the whole
    4.33 -    # argument.
    4.34 -    path="$complete"
    4.35 -    arguments="EOL"
    4.36 -    new_path=`$CYGPATH -u "$path"`
    4.37 -    new_path=`$WHICH "$new_path" 2> /dev/null`
    4.38 +  # bat and cmd files are not always considered executable in cygwin causing which
    4.39 +  # to not find them
    4.40 +  if test "x$new_path" = x \
    4.41 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
    4.42 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
    4.43 +    new_path=`$CYGPATH -u "$path"`
    4.44 +  fi
    4.45 +  if test "x$new_path" = x; then
    4.46 +    # Oops. Which didn't find the executable.
    4.47 +    # The splitting of arguments from the executable at a space might have been incorrect,
    4.48 +    # since paths with space are more likely in Windows. Give it another try with the whole
    4.49 +    # argument.
    4.50 +    path="$complete"
    4.51 +    arguments="EOL"
    4.52 +    new_path=`$CYGPATH -u "$path"`
    4.53 +    new_path=`$WHICH "$new_path" 2> /dev/null`
    4.54 +    # bat and cmd files are not always considered executable in cygwin causing which
    4.55 +    # to not find them
    4.56 +    if test "x$new_path" = x \
    4.57 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
    4.58 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
    4.59 +      new_path=`$CYGPATH -u "$path"`
    4.60 +    fi
    4.61      if test "x$new_path" = x; then
    4.62        # It's still not found. Now this is an unrecoverable error.
    4.63        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
    4.64 @@ -8221,15 +8239,29 @@
    4.65  
    4.66    # Now try to locate executable using which
    4.67    new_path=`$WHICH "$new_path" 2> /dev/null`
    4.68 -  if test "x$new_path" = x; then
    4.69 -    # Oops. Which didn't find the executable.
    4.70 -    # The splitting of arguments from the executable at a space might have been incorrect,
    4.71 -    # since paths with space are more likely in Windows. Give it another try with the whole
    4.72 -    # argument.
    4.73 -    path="$complete"
    4.74 -    arguments="EOL"
    4.75 -    new_path=`$CYGPATH -u "$path"`
    4.76 -    new_path=`$WHICH "$new_path" 2> /dev/null`
    4.77 +  # bat and cmd files are not always considered executable in cygwin causing which
    4.78 +  # to not find them
    4.79 +  if test "x$new_path" = x \
    4.80 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
    4.81 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
    4.82 +    new_path=`$CYGPATH -u "$path"`
    4.83 +  fi
    4.84 +  if test "x$new_path" = x; then
    4.85 +    # Oops. Which didn't find the executable.
    4.86 +    # The splitting of arguments from the executable at a space might have been incorrect,
    4.87 +    # since paths with space are more likely in Windows. Give it another try with the whole
    4.88 +    # argument.
    4.89 +    path="$complete"
    4.90 +    arguments="EOL"
    4.91 +    new_path=`$CYGPATH -u "$path"`
    4.92 +    new_path=`$WHICH "$new_path" 2> /dev/null`
    4.93 +    # bat and cmd files are not always considered executable in cygwin causing which
    4.94 +    # to not find them
    4.95 +    if test "x$new_path" = x \
    4.96 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
    4.97 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
    4.98 +      new_path=`$CYGPATH -u "$path"`
    4.99 +    fi
   4.100      if test "x$new_path" = x; then
   4.101        # It's still not found. Now this is an unrecoverable error.
   4.102        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
   4.103 @@ -8550,15 +8582,29 @@
   4.104  
   4.105    # Now try to locate executable using which
   4.106    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.107 -  if test "x$new_path" = x; then
   4.108 -    # Oops. Which didn't find the executable.
   4.109 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.110 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.111 -    # argument.
   4.112 -    path="$complete"
   4.113 -    arguments="EOL"
   4.114 -    new_path=`$CYGPATH -u "$path"`
   4.115 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.116 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.117 +  # to not find them
   4.118 +  if test "x$new_path" = x \
   4.119 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.120 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.121 +    new_path=`$CYGPATH -u "$path"`
   4.122 +  fi
   4.123 +  if test "x$new_path" = x; then
   4.124 +    # Oops. Which didn't find the executable.
   4.125 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.126 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.127 +    # argument.
   4.128 +    path="$complete"
   4.129 +    arguments="EOL"
   4.130 +    new_path=`$CYGPATH -u "$path"`
   4.131 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.132 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.133 +    # to not find them
   4.134 +    if test "x$new_path" = x \
   4.135 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.136 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.137 +      new_path=`$CYGPATH -u "$path"`
   4.138 +    fi
   4.139      if test "x$new_path" = x; then
   4.140        # It's still not found. Now this is an unrecoverable error.
   4.141        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
   4.142 @@ -8884,15 +8930,29 @@
   4.143  
   4.144    # Now try to locate executable using which
   4.145    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.146 -  if test "x$new_path" = x; then
   4.147 -    # Oops. Which didn't find the executable.
   4.148 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.149 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.150 -    # argument.
   4.151 -    path="$complete"
   4.152 -    arguments="EOL"
   4.153 -    new_path=`$CYGPATH -u "$path"`
   4.154 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.155 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.156 +  # to not find them
   4.157 +  if test "x$new_path" = x \
   4.158 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.159 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.160 +    new_path=`$CYGPATH -u "$path"`
   4.161 +  fi
   4.162 +  if test "x$new_path" = x; then
   4.163 +    # Oops. Which didn't find the executable.
   4.164 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.165 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.166 +    # argument.
   4.167 +    path="$complete"
   4.168 +    arguments="EOL"
   4.169 +    new_path=`$CYGPATH -u "$path"`
   4.170 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.171 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.172 +    # to not find them
   4.173 +    if test "x$new_path" = x \
   4.174 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.175 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.176 +      new_path=`$CYGPATH -u "$path"`
   4.177 +    fi
   4.178      if test "x$new_path" = x; then
   4.179        # It's still not found. Now this is an unrecoverable error.
   4.180        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
   4.181 @@ -9212,15 +9272,29 @@
   4.182  
   4.183    # Now try to locate executable using which
   4.184    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.185 -  if test "x$new_path" = x; then
   4.186 -    # Oops. Which didn't find the executable.
   4.187 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.188 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.189 -    # argument.
   4.190 -    path="$complete"
   4.191 -    arguments="EOL"
   4.192 -    new_path=`$CYGPATH -u "$path"`
   4.193 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.194 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.195 +  # to not find them
   4.196 +  if test "x$new_path" = x \
   4.197 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.198 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.199 +    new_path=`$CYGPATH -u "$path"`
   4.200 +  fi
   4.201 +  if test "x$new_path" = x; then
   4.202 +    # Oops. Which didn't find the executable.
   4.203 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.204 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.205 +    # argument.
   4.206 +    path="$complete"
   4.207 +    arguments="EOL"
   4.208 +    new_path=`$CYGPATH -u "$path"`
   4.209 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.210 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.211 +    # to not find them
   4.212 +    if test "x$new_path" = x \
   4.213 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.214 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.215 +      new_path=`$CYGPATH -u "$path"`
   4.216 +    fi
   4.217      if test "x$new_path" = x; then
   4.218        # It's still not found. Now this is an unrecoverable error.
   4.219        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
   4.220 @@ -15963,15 +16037,29 @@
   4.221  
   4.222    # Now try to locate executable using which
   4.223    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.224 -  if test "x$new_path" = x; then
   4.225 -    # Oops. Which didn't find the executable.
   4.226 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.227 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.228 -    # argument.
   4.229 -    path="$complete"
   4.230 -    arguments="EOL"
   4.231 -    new_path=`$CYGPATH -u "$path"`
   4.232 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.233 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.234 +  # to not find them
   4.235 +  if test "x$new_path" = x \
   4.236 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.237 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.238 +    new_path=`$CYGPATH -u "$path"`
   4.239 +  fi
   4.240 +  if test "x$new_path" = x; then
   4.241 +    # Oops. Which didn't find the executable.
   4.242 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.243 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.244 +    # argument.
   4.245 +    path="$complete"
   4.246 +    arguments="EOL"
   4.247 +    new_path=`$CYGPATH -u "$path"`
   4.248 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.249 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.250 +    # to not find them
   4.251 +    if test "x$new_path" = x \
   4.252 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.253 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.254 +      new_path=`$CYGPATH -u "$path"`
   4.255 +    fi
   4.256      if test "x$new_path" = x; then
   4.257        # It's still not found. Now this is an unrecoverable error.
   4.258        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
   4.259 @@ -16537,15 +16625,29 @@
   4.260  
   4.261    # Now try to locate executable using which
   4.262    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.263 -  if test "x$new_path" = x; then
   4.264 -    # Oops. Which didn't find the executable.
   4.265 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.266 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.267 -    # argument.
   4.268 -    path="$complete"
   4.269 -    arguments="EOL"
   4.270 -    new_path=`$CYGPATH -u "$path"`
   4.271 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.272 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.273 +  # to not find them
   4.274 +  if test "x$new_path" = x \
   4.275 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.276 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.277 +    new_path=`$CYGPATH -u "$path"`
   4.278 +  fi
   4.279 +  if test "x$new_path" = x; then
   4.280 +    # Oops. Which didn't find the executable.
   4.281 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.282 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.283 +    # argument.
   4.284 +    path="$complete"
   4.285 +    arguments="EOL"
   4.286 +    new_path=`$CYGPATH -u "$path"`
   4.287 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.288 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.289 +    # to not find them
   4.290 +    if test "x$new_path" = x \
   4.291 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.292 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.293 +      new_path=`$CYGPATH -u "$path"`
   4.294 +    fi
   4.295      if test "x$new_path" = x; then
   4.296        # It's still not found. Now this is an unrecoverable error.
   4.297        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
   4.298 @@ -16823,15 +16925,29 @@
   4.299  
   4.300    # Now try to locate executable using which
   4.301    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.302 -  if test "x$new_path" = x; then
   4.303 -    # Oops. Which didn't find the executable.
   4.304 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.305 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.306 -    # argument.
   4.307 -    path="$complete"
   4.308 -    arguments="EOL"
   4.309 -    new_path=`$CYGPATH -u "$path"`
   4.310 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.311 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.312 +  # to not find them
   4.313 +  if test "x$new_path" = x \
   4.314 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.315 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.316 +    new_path=`$CYGPATH -u "$path"`
   4.317 +  fi
   4.318 +  if test "x$new_path" = x; then
   4.319 +    # Oops. Which didn't find the executable.
   4.320 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.321 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.322 +    # argument.
   4.323 +    path="$complete"
   4.324 +    arguments="EOL"
   4.325 +    new_path=`$CYGPATH -u "$path"`
   4.326 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.327 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.328 +    # to not find them
   4.329 +    if test "x$new_path" = x \
   4.330 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.331 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.332 +      new_path=`$CYGPATH -u "$path"`
   4.333 +    fi
   4.334      if test "x$new_path" = x; then
   4.335        # It's still not found. Now this is an unrecoverable error.
   4.336        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
   4.337 @@ -17104,15 +17220,29 @@
   4.338  
   4.339    # Now try to locate executable using which
   4.340    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.341 -  if test "x$new_path" = x; then
   4.342 -    # Oops. Which didn't find the executable.
   4.343 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.344 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.345 -    # argument.
   4.346 -    path="$complete"
   4.347 -    arguments="EOL"
   4.348 -    new_path=`$CYGPATH -u "$path"`
   4.349 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.350 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.351 +  # to not find them
   4.352 +  if test "x$new_path" = x \
   4.353 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.354 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.355 +    new_path=`$CYGPATH -u "$path"`
   4.356 +  fi
   4.357 +  if test "x$new_path" = x; then
   4.358 +    # Oops. Which didn't find the executable.
   4.359 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.360 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.361 +    # argument.
   4.362 +    path="$complete"
   4.363 +    arguments="EOL"
   4.364 +    new_path=`$CYGPATH -u "$path"`
   4.365 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.366 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.367 +    # to not find them
   4.368 +    if test "x$new_path" = x \
   4.369 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.370 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.371 +      new_path=`$CYGPATH -u "$path"`
   4.372 +    fi
   4.373      if test "x$new_path" = x; then
   4.374        # It's still not found. Now this is an unrecoverable error.
   4.375        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
   4.376 @@ -17621,15 +17751,29 @@
   4.377  
   4.378    # Now try to locate executable using which
   4.379    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.380 -  if test "x$new_path" = x; then
   4.381 -    # Oops. Which didn't find the executable.
   4.382 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.383 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.384 -    # argument.
   4.385 -    path="$complete"
   4.386 -    arguments="EOL"
   4.387 -    new_path=`$CYGPATH -u "$path"`
   4.388 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.389 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.390 +  # to not find them
   4.391 +  if test "x$new_path" = x \
   4.392 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.393 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.394 +    new_path=`$CYGPATH -u "$path"`
   4.395 +  fi
   4.396 +  if test "x$new_path" = x; then
   4.397 +    # Oops. Which didn't find the executable.
   4.398 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.399 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.400 +    # argument.
   4.401 +    path="$complete"
   4.402 +    arguments="EOL"
   4.403 +    new_path=`$CYGPATH -u "$path"`
   4.404 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.405 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.406 +    # to not find them
   4.407 +    if test "x$new_path" = x \
   4.408 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.409 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.410 +      new_path=`$CYGPATH -u "$path"`
   4.411 +    fi
   4.412      if test "x$new_path" = x; then
   4.413        # It's still not found. Now this is an unrecoverable error.
   4.414        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
   4.415 @@ -18028,15 +18172,29 @@
   4.416  
   4.417    # Now try to locate executable using which
   4.418    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.419 -  if test "x$new_path" = x; then
   4.420 -    # Oops. Which didn't find the executable.
   4.421 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.422 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.423 -    # argument.
   4.424 -    path="$complete"
   4.425 -    arguments="EOL"
   4.426 -    new_path=`$CYGPATH -u "$path"`
   4.427 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.428 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.429 +  # to not find them
   4.430 +  if test "x$new_path" = x \
   4.431 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.432 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.433 +    new_path=`$CYGPATH -u "$path"`
   4.434 +  fi
   4.435 +  if test "x$new_path" = x; then
   4.436 +    # Oops. Which didn't find the executable.
   4.437 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.438 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.439 +    # argument.
   4.440 +    path="$complete"
   4.441 +    arguments="EOL"
   4.442 +    new_path=`$CYGPATH -u "$path"`
   4.443 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.444 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.445 +    # to not find them
   4.446 +    if test "x$new_path" = x \
   4.447 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.448 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.449 +      new_path=`$CYGPATH -u "$path"`
   4.450 +    fi
   4.451      if test "x$new_path" = x; then
   4.452        # It's still not found. Now this is an unrecoverable error.
   4.453        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
   4.454 @@ -19076,15 +19234,29 @@
   4.455  
   4.456    # Now try to locate executable using which
   4.457    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.458 -  if test "x$new_path" = x; then
   4.459 -    # Oops. Which didn't find the executable.
   4.460 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.461 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.462 -    # argument.
   4.463 -    path="$complete"
   4.464 -    arguments="EOL"
   4.465 -    new_path=`$CYGPATH -u "$path"`
   4.466 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.467 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.468 +  # to not find them
   4.469 +  if test "x$new_path" = x \
   4.470 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.471 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.472 +    new_path=`$CYGPATH -u "$path"`
   4.473 +  fi
   4.474 +  if test "x$new_path" = x; then
   4.475 +    # Oops. Which didn't find the executable.
   4.476 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.477 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.478 +    # argument.
   4.479 +    path="$complete"
   4.480 +    arguments="EOL"
   4.481 +    new_path=`$CYGPATH -u "$path"`
   4.482 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.483 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.484 +    # to not find them
   4.485 +    if test "x$new_path" = x \
   4.486 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.487 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.488 +      new_path=`$CYGPATH -u "$path"`
   4.489 +    fi
   4.490      if test "x$new_path" = x; then
   4.491        # It's still not found. Now this is an unrecoverable error.
   4.492        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
   4.493 @@ -19483,15 +19655,29 @@
   4.494  
   4.495    # Now try to locate executable using which
   4.496    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.497 -  if test "x$new_path" = x; then
   4.498 -    # Oops. Which didn't find the executable.
   4.499 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.500 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.501 -    # argument.
   4.502 -    path="$complete"
   4.503 -    arguments="EOL"
   4.504 -    new_path=`$CYGPATH -u "$path"`
   4.505 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.506 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.507 +  # to not find them
   4.508 +  if test "x$new_path" = x \
   4.509 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.510 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.511 +    new_path=`$CYGPATH -u "$path"`
   4.512 +  fi
   4.513 +  if test "x$new_path" = x; then
   4.514 +    # Oops. Which didn't find the executable.
   4.515 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.516 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.517 +    # argument.
   4.518 +    path="$complete"
   4.519 +    arguments="EOL"
   4.520 +    new_path=`$CYGPATH -u "$path"`
   4.521 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.522 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.523 +    # to not find them
   4.524 +    if test "x$new_path" = x \
   4.525 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.526 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.527 +      new_path=`$CYGPATH -u "$path"`
   4.528 +    fi
   4.529      if test "x$new_path" = x; then
   4.530        # It's still not found. Now this is an unrecoverable error.
   4.531        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
   4.532 @@ -20355,15 +20541,29 @@
   4.533  
   4.534    # Now try to locate executable using which
   4.535    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.536 -  if test "x$new_path" = x; then
   4.537 -    # Oops. Which didn't find the executable.
   4.538 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.539 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.540 -    # argument.
   4.541 -    path="$complete"
   4.542 -    arguments="EOL"
   4.543 -    new_path=`$CYGPATH -u "$path"`
   4.544 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.545 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.546 +  # to not find them
   4.547 +  if test "x$new_path" = x \
   4.548 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.549 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.550 +    new_path=`$CYGPATH -u "$path"`
   4.551 +  fi
   4.552 +  if test "x$new_path" = x; then
   4.553 +    # Oops. Which didn't find the executable.
   4.554 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.555 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.556 +    # argument.
   4.557 +    path="$complete"
   4.558 +    arguments="EOL"
   4.559 +    new_path=`$CYGPATH -u "$path"`
   4.560 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.561 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.562 +    # to not find them
   4.563 +    if test "x$new_path" = x \
   4.564 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.565 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.566 +      new_path=`$CYGPATH -u "$path"`
   4.567 +    fi
   4.568      if test "x$new_path" = x; then
   4.569        # It's still not found. Now this is an unrecoverable error.
   4.570        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
   4.571 @@ -20711,15 +20911,29 @@
   4.572  
   4.573    # Now try to locate executable using which
   4.574    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.575 -  if test "x$new_path" = x; then
   4.576 -    # Oops. Which didn't find the executable.
   4.577 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.578 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.579 -    # argument.
   4.580 -    path="$complete"
   4.581 -    arguments="EOL"
   4.582 -    new_path=`$CYGPATH -u "$path"`
   4.583 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.584 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.585 +  # to not find them
   4.586 +  if test "x$new_path" = x \
   4.587 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.588 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.589 +    new_path=`$CYGPATH -u "$path"`
   4.590 +  fi
   4.591 +  if test "x$new_path" = x; then
   4.592 +    # Oops. Which didn't find the executable.
   4.593 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.594 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.595 +    # argument.
   4.596 +    path="$complete"
   4.597 +    arguments="EOL"
   4.598 +    new_path=`$CYGPATH -u "$path"`
   4.599 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.600 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.601 +    # to not find them
   4.602 +    if test "x$new_path" = x \
   4.603 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.604 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.605 +      new_path=`$CYGPATH -u "$path"`
   4.606 +    fi
   4.607      if test "x$new_path" = x; then
   4.608        # It's still not found. Now this is an unrecoverable error.
   4.609        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
   4.610 @@ -21033,15 +21247,29 @@
   4.611  
   4.612    # Now try to locate executable using which
   4.613    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.614 -  if test "x$new_path" = x; then
   4.615 -    # Oops. Which didn't find the executable.
   4.616 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.617 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.618 -    # argument.
   4.619 -    path="$complete"
   4.620 -    arguments="EOL"
   4.621 -    new_path=`$CYGPATH -u "$path"`
   4.622 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.623 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.624 +  # to not find them
   4.625 +  if test "x$new_path" = x \
   4.626 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.627 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.628 +    new_path=`$CYGPATH -u "$path"`
   4.629 +  fi
   4.630 +  if test "x$new_path" = x; then
   4.631 +    # Oops. Which didn't find the executable.
   4.632 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.633 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.634 +    # argument.
   4.635 +    path="$complete"
   4.636 +    arguments="EOL"
   4.637 +    new_path=`$CYGPATH -u "$path"`
   4.638 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.639 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.640 +    # to not find them
   4.641 +    if test "x$new_path" = x \
   4.642 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.643 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.644 +      new_path=`$CYGPATH -u "$path"`
   4.645 +    fi
   4.646      if test "x$new_path" = x; then
   4.647        # It's still not found. Now this is an unrecoverable error.
   4.648        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of WINLD, which resolves as \"$complete\", is not found." >&5
   4.649 @@ -21345,15 +21573,29 @@
   4.650  
   4.651    # Now try to locate executable using which
   4.652    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.653 -  if test "x$new_path" = x; then
   4.654 -    # Oops. Which didn't find the executable.
   4.655 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.656 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.657 -    # argument.
   4.658 -    path="$complete"
   4.659 -    arguments="EOL"
   4.660 -    new_path=`$CYGPATH -u "$path"`
   4.661 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.662 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.663 +  # to not find them
   4.664 +  if test "x$new_path" = x \
   4.665 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.666 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.667 +    new_path=`$CYGPATH -u "$path"`
   4.668 +  fi
   4.669 +  if test "x$new_path" = x; then
   4.670 +    # Oops. Which didn't find the executable.
   4.671 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.672 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.673 +    # argument.
   4.674 +    path="$complete"
   4.675 +    arguments="EOL"
   4.676 +    new_path=`$CYGPATH -u "$path"`
   4.677 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.678 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.679 +    # to not find them
   4.680 +    if test "x$new_path" = x \
   4.681 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.682 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.683 +      new_path=`$CYGPATH -u "$path"`
   4.684 +    fi
   4.685      if test "x$new_path" = x; then
   4.686        # It's still not found. Now this is an unrecoverable error.
   4.687        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
   4.688 @@ -21641,15 +21883,29 @@
   4.689  
   4.690    # Now try to locate executable using which
   4.691    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.692 -  if test "x$new_path" = x; then
   4.693 -    # Oops. Which didn't find the executable.
   4.694 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.695 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.696 -    # argument.
   4.697 -    path="$complete"
   4.698 -    arguments="EOL"
   4.699 -    new_path=`$CYGPATH -u "$path"`
   4.700 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.701 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.702 +  # to not find them
   4.703 +  if test "x$new_path" = x \
   4.704 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.705 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.706 +    new_path=`$CYGPATH -u "$path"`
   4.707 +  fi
   4.708 +  if test "x$new_path" = x; then
   4.709 +    # Oops. Which didn't find the executable.
   4.710 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.711 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.712 +    # argument.
   4.713 +    path="$complete"
   4.714 +    arguments="EOL"
   4.715 +    new_path=`$CYGPATH -u "$path"`
   4.716 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.717 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.718 +    # to not find them
   4.719 +    if test "x$new_path" = x \
   4.720 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.721 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.722 +      new_path=`$CYGPATH -u "$path"`
   4.723 +    fi
   4.724      if test "x$new_path" = x; then
   4.725        # It's still not found. Now this is an unrecoverable error.
   4.726        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
   4.727 @@ -21990,15 +22246,29 @@
   4.728  
   4.729    # Now try to locate executable using which
   4.730    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.731 -  if test "x$new_path" = x; then
   4.732 -    # Oops. Which didn't find the executable.
   4.733 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.734 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.735 -    # argument.
   4.736 -    path="$complete"
   4.737 -    arguments="EOL"
   4.738 -    new_path=`$CYGPATH -u "$path"`
   4.739 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.740 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.741 +  # to not find them
   4.742 +  if test "x$new_path" = x \
   4.743 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.744 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.745 +    new_path=`$CYGPATH -u "$path"`
   4.746 +  fi
   4.747 +  if test "x$new_path" = x; then
   4.748 +    # Oops. Which didn't find the executable.
   4.749 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.750 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.751 +    # argument.
   4.752 +    path="$complete"
   4.753 +    arguments="EOL"
   4.754 +    new_path=`$CYGPATH -u "$path"`
   4.755 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.756 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.757 +    # to not find them
   4.758 +    if test "x$new_path" = x \
   4.759 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.760 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.761 +      new_path=`$CYGPATH -u "$path"`
   4.762 +    fi
   4.763      if test "x$new_path" = x; then
   4.764        # It's still not found. Now this is an unrecoverable error.
   4.765        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of WINAR, which resolves as \"$complete\", is not found." >&5
   4.766 @@ -22271,15 +22541,29 @@
   4.767  
   4.768    # Now try to locate executable using which
   4.769    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.770 -  if test "x$new_path" = x; then
   4.771 -    # Oops. Which didn't find the executable.
   4.772 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.773 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.774 -    # argument.
   4.775 -    path="$complete"
   4.776 -    arguments="EOL"
   4.777 -    new_path=`$CYGPATH -u "$path"`
   4.778 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.779 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.780 +  # to not find them
   4.781 +  if test "x$new_path" = x \
   4.782 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.783 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.784 +    new_path=`$CYGPATH -u "$path"`
   4.785 +  fi
   4.786 +  if test "x$new_path" = x; then
   4.787 +    # Oops. Which didn't find the executable.
   4.788 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.789 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.790 +    # argument.
   4.791 +    path="$complete"
   4.792 +    arguments="EOL"
   4.793 +    new_path=`$CYGPATH -u "$path"`
   4.794 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.795 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.796 +    # to not find them
   4.797 +    if test "x$new_path" = x \
   4.798 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.799 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.800 +      new_path=`$CYGPATH -u "$path"`
   4.801 +    fi
   4.802      if test "x$new_path" = x; then
   4.803        # It's still not found. Now this is an unrecoverable error.
   4.804        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
   4.805 @@ -22657,15 +22941,29 @@
   4.806  
   4.807    # Now try to locate executable using which
   4.808    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.809 -  if test "x$new_path" = x; then
   4.810 -    # Oops. Which didn't find the executable.
   4.811 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.812 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.813 -    # argument.
   4.814 -    path="$complete"
   4.815 -    arguments="EOL"
   4.816 -    new_path=`$CYGPATH -u "$path"`
   4.817 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.818 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.819 +  # to not find them
   4.820 +  if test "x$new_path" = x \
   4.821 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.822 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.823 +    new_path=`$CYGPATH -u "$path"`
   4.824 +  fi
   4.825 +  if test "x$new_path" = x; then
   4.826 +    # Oops. Which didn't find the executable.
   4.827 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.828 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.829 +    # argument.
   4.830 +    path="$complete"
   4.831 +    arguments="EOL"
   4.832 +    new_path=`$CYGPATH -u "$path"`
   4.833 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.834 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.835 +    # to not find them
   4.836 +    if test "x$new_path" = x \
   4.837 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.838 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.839 +      new_path=`$CYGPATH -u "$path"`
   4.840 +    fi
   4.841      if test "x$new_path" = x; then
   4.842        # It's still not found. Now this is an unrecoverable error.
   4.843        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
   4.844 @@ -23032,15 +23330,29 @@
   4.845  
   4.846    # Now try to locate executable using which
   4.847    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.848 -  if test "x$new_path" = x; then
   4.849 -    # Oops. Which didn't find the executable.
   4.850 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.851 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.852 -    # argument.
   4.853 -    path="$complete"
   4.854 -    arguments="EOL"
   4.855 -    new_path=`$CYGPATH -u "$path"`
   4.856 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.857 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.858 +  # to not find them
   4.859 +  if test "x$new_path" = x \
   4.860 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.861 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.862 +    new_path=`$CYGPATH -u "$path"`
   4.863 +  fi
   4.864 +  if test "x$new_path" = x; then
   4.865 +    # Oops. Which didn't find the executable.
   4.866 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.867 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.868 +    # argument.
   4.869 +    path="$complete"
   4.870 +    arguments="EOL"
   4.871 +    new_path=`$CYGPATH -u "$path"`
   4.872 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.873 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.874 +    # to not find them
   4.875 +    if test "x$new_path" = x \
   4.876 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.877 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.878 +      new_path=`$CYGPATH -u "$path"`
   4.879 +    fi
   4.880      if test "x$new_path" = x; then
   4.881        # It's still not found. Now this is an unrecoverable error.
   4.882        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
   4.883 @@ -23336,15 +23648,29 @@
   4.884  
   4.885    # Now try to locate executable using which
   4.886    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.887 -  if test "x$new_path" = x; then
   4.888 -    # Oops. Which didn't find the executable.
   4.889 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.890 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.891 -    # argument.
   4.892 -    path="$complete"
   4.893 -    arguments="EOL"
   4.894 -    new_path=`$CYGPATH -u "$path"`
   4.895 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.896 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.897 +  # to not find them
   4.898 +  if test "x$new_path" = x \
   4.899 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.900 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.901 +    new_path=`$CYGPATH -u "$path"`
   4.902 +  fi
   4.903 +  if test "x$new_path" = x; then
   4.904 +    # Oops. Which didn't find the executable.
   4.905 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.906 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.907 +    # argument.
   4.908 +    path="$complete"
   4.909 +    arguments="EOL"
   4.910 +    new_path=`$CYGPATH -u "$path"`
   4.911 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.912 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.913 +    # to not find them
   4.914 +    if test "x$new_path" = x \
   4.915 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.916 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.917 +      new_path=`$CYGPATH -u "$path"`
   4.918 +    fi
   4.919      if test "x$new_path" = x; then
   4.920        # It's still not found. Now this is an unrecoverable error.
   4.921        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
   4.922 @@ -23628,15 +23954,29 @@
   4.923  
   4.924    # Now try to locate executable using which
   4.925    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.926 -  if test "x$new_path" = x; then
   4.927 -    # Oops. Which didn't find the executable.
   4.928 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.929 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.930 -    # argument.
   4.931 -    path="$complete"
   4.932 -    arguments="EOL"
   4.933 -    new_path=`$CYGPATH -u "$path"`
   4.934 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.935 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.936 +  # to not find them
   4.937 +  if test "x$new_path" = x \
   4.938 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.939 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.940 +    new_path=`$CYGPATH -u "$path"`
   4.941 +  fi
   4.942 +  if test "x$new_path" = x; then
   4.943 +    # Oops. Which didn't find the executable.
   4.944 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.945 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.946 +    # argument.
   4.947 +    path="$complete"
   4.948 +    arguments="EOL"
   4.949 +    new_path=`$CYGPATH -u "$path"`
   4.950 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.951 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.952 +    # to not find them
   4.953 +    if test "x$new_path" = x \
   4.954 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.955 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.956 +      new_path=`$CYGPATH -u "$path"`
   4.957 +    fi
   4.958      if test "x$new_path" = x; then
   4.959        # It's still not found. Now this is an unrecoverable error.
   4.960        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
   4.961 @@ -23909,15 +24249,29 @@
   4.962  
   4.963    # Now try to locate executable using which
   4.964    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.965 -  if test "x$new_path" = x; then
   4.966 -    # Oops. Which didn't find the executable.
   4.967 -    # The splitting of arguments from the executable at a space might have been incorrect,
   4.968 -    # since paths with space are more likely in Windows. Give it another try with the whole
   4.969 -    # argument.
   4.970 -    path="$complete"
   4.971 -    arguments="EOL"
   4.972 -    new_path=`$CYGPATH -u "$path"`
   4.973 -    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.974 +  # bat and cmd files are not always considered executable in cygwin causing which
   4.975 +  # to not find them
   4.976 +  if test "x$new_path" = x \
   4.977 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.978 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.979 +    new_path=`$CYGPATH -u "$path"`
   4.980 +  fi
   4.981 +  if test "x$new_path" = x; then
   4.982 +    # Oops. Which didn't find the executable.
   4.983 +    # The splitting of arguments from the executable at a space might have been incorrect,
   4.984 +    # since paths with space are more likely in Windows. Give it another try with the whole
   4.985 +    # argument.
   4.986 +    path="$complete"
   4.987 +    arguments="EOL"
   4.988 +    new_path=`$CYGPATH -u "$path"`
   4.989 +    new_path=`$WHICH "$new_path" 2> /dev/null`
   4.990 +    # bat and cmd files are not always considered executable in cygwin causing which
   4.991 +    # to not find them
   4.992 +    if test "x$new_path" = x \
   4.993 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
   4.994 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
   4.995 +      new_path=`$CYGPATH -u "$path"`
   4.996 +    fi
   4.997      if test "x$new_path" = x; then
   4.998        # It's still not found. Now this is an unrecoverable error.
   4.999        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
  4.1000 @@ -24190,15 +24544,29 @@
  4.1001  
  4.1002    # Now try to locate executable using which
  4.1003    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1004 -  if test "x$new_path" = x; then
  4.1005 -    # Oops. Which didn't find the executable.
  4.1006 -    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1007 -    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1008 -    # argument.
  4.1009 -    path="$complete"
  4.1010 -    arguments="EOL"
  4.1011 -    new_path=`$CYGPATH -u "$path"`
  4.1012 -    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1013 +  # bat and cmd files are not always considered executable in cygwin causing which
  4.1014 +  # to not find them
  4.1015 +  if test "x$new_path" = x \
  4.1016 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1017 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1018 +    new_path=`$CYGPATH -u "$path"`
  4.1019 +  fi
  4.1020 +  if test "x$new_path" = x; then
  4.1021 +    # Oops. Which didn't find the executable.
  4.1022 +    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1023 +    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1024 +    # argument.
  4.1025 +    path="$complete"
  4.1026 +    arguments="EOL"
  4.1027 +    new_path=`$CYGPATH -u "$path"`
  4.1028 +    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1029 +    # bat and cmd files are not always considered executable in cygwin causing which
  4.1030 +    # to not find them
  4.1031 +    if test "x$new_path" = x \
  4.1032 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1033 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1034 +      new_path=`$CYGPATH -u "$path"`
  4.1035 +    fi
  4.1036      if test "x$new_path" = x; then
  4.1037        # It's still not found. Now this is an unrecoverable error.
  4.1038        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
  4.1039 @@ -24524,15 +24892,29 @@
  4.1040  
  4.1041    # Now try to locate executable using which
  4.1042    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1043 -  if test "x$new_path" = x; then
  4.1044 -    # Oops. Which didn't find the executable.
  4.1045 -    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1046 -    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1047 -    # argument.
  4.1048 -    path="$complete"
  4.1049 -    arguments="EOL"
  4.1050 -    new_path=`$CYGPATH -u "$path"`
  4.1051 -    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1052 +  # bat and cmd files are not always considered executable in cygwin causing which
  4.1053 +  # to not find them
  4.1054 +  if test "x$new_path" = x \
  4.1055 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1056 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1057 +    new_path=`$CYGPATH -u "$path"`
  4.1058 +  fi
  4.1059 +  if test "x$new_path" = x; then
  4.1060 +    # Oops. Which didn't find the executable.
  4.1061 +    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1062 +    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1063 +    # argument.
  4.1064 +    path="$complete"
  4.1065 +    arguments="EOL"
  4.1066 +    new_path=`$CYGPATH -u "$path"`
  4.1067 +    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1068 +    # bat and cmd files are not always considered executable in cygwin causing which
  4.1069 +    # to not find them
  4.1070 +    if test "x$new_path" = x \
  4.1071 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1072 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1073 +      new_path=`$CYGPATH -u "$path"`
  4.1074 +    fi
  4.1075      if test "x$new_path" = x; then
  4.1076        # It's still not found. Now this is an unrecoverable error.
  4.1077        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
  4.1078 @@ -24857,15 +25239,29 @@
  4.1079  
  4.1080    # Now try to locate executable using which
  4.1081    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1082 -  if test "x$new_path" = x; then
  4.1083 -    # Oops. Which didn't find the executable.
  4.1084 -    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1085 -    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1086 -    # argument.
  4.1087 -    path="$complete"
  4.1088 -    arguments="EOL"
  4.1089 -    new_path=`$CYGPATH -u "$path"`
  4.1090 -    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1091 +  # bat and cmd files are not always considered executable in cygwin causing which
  4.1092 +  # to not find them
  4.1093 +  if test "x$new_path" = x \
  4.1094 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1095 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1096 +    new_path=`$CYGPATH -u "$path"`
  4.1097 +  fi
  4.1098 +  if test "x$new_path" = x; then
  4.1099 +    # Oops. Which didn't find the executable.
  4.1100 +    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1101 +    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1102 +    # argument.
  4.1103 +    path="$complete"
  4.1104 +    arguments="EOL"
  4.1105 +    new_path=`$CYGPATH -u "$path"`
  4.1106 +    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1107 +    # bat and cmd files are not always considered executable in cygwin causing which
  4.1108 +    # to not find them
  4.1109 +    if test "x$new_path" = x \
  4.1110 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1111 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1112 +      new_path=`$CYGPATH -u "$path"`
  4.1113 +    fi
  4.1114      if test "x$new_path" = x; then
  4.1115        # It's still not found. Now this is an unrecoverable error.
  4.1116        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
  4.1117 @@ -25203,15 +25599,29 @@
  4.1118  
  4.1119    # Now try to locate executable using which
  4.1120    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1121 -  if test "x$new_path" = x; then
  4.1122 -    # Oops. Which didn't find the executable.
  4.1123 -    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1124 -    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1125 -    # argument.
  4.1126 -    path="$complete"
  4.1127 -    arguments="EOL"
  4.1128 -    new_path=`$CYGPATH -u "$path"`
  4.1129 -    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1130 +  # bat and cmd files are not always considered executable in cygwin causing which
  4.1131 +  # to not find them
  4.1132 +  if test "x$new_path" = x \
  4.1133 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1134 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1135 +    new_path=`$CYGPATH -u "$path"`
  4.1136 +  fi
  4.1137 +  if test "x$new_path" = x; then
  4.1138 +    # Oops. Which didn't find the executable.
  4.1139 +    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1140 +    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1141 +    # argument.
  4.1142 +    path="$complete"
  4.1143 +    arguments="EOL"
  4.1144 +    new_path=`$CYGPATH -u "$path"`
  4.1145 +    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1146 +    # bat and cmd files are not always considered executable in cygwin causing which
  4.1147 +    # to not find them
  4.1148 +    if test "x$new_path" = x \
  4.1149 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1150 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1151 +      new_path=`$CYGPATH -u "$path"`
  4.1152 +    fi
  4.1153      if test "x$new_path" = x; then
  4.1154        # It's still not found. Now this is an unrecoverable error.
  4.1155        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
  4.1156 @@ -25548,15 +25958,29 @@
  4.1157  
  4.1158    # Now try to locate executable using which
  4.1159    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1160 -  if test "x$new_path" = x; then
  4.1161 -    # Oops. Which didn't find the executable.
  4.1162 -    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1163 -    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1164 -    # argument.
  4.1165 -    path="$complete"
  4.1166 -    arguments="EOL"
  4.1167 -    new_path=`$CYGPATH -u "$path"`
  4.1168 -    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1169 +  # bat and cmd files are not always considered executable in cygwin causing which
  4.1170 +  # to not find them
  4.1171 +  if test "x$new_path" = x \
  4.1172 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1173 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1174 +    new_path=`$CYGPATH -u "$path"`
  4.1175 +  fi
  4.1176 +  if test "x$new_path" = x; then
  4.1177 +    # Oops. Which didn't find the executable.
  4.1178 +    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1179 +    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1180 +    # argument.
  4.1181 +    path="$complete"
  4.1182 +    arguments="EOL"
  4.1183 +    new_path=`$CYGPATH -u "$path"`
  4.1184 +    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1185 +    # bat and cmd files are not always considered executable in cygwin causing which
  4.1186 +    # to not find them
  4.1187 +    if test "x$new_path" = x \
  4.1188 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1189 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1190 +      new_path=`$CYGPATH -u "$path"`
  4.1191 +    fi
  4.1192      if test "x$new_path" = x; then
  4.1193        # It's still not found. Now this is an unrecoverable error.
  4.1194        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
  4.1195 @@ -25832,15 +26256,29 @@
  4.1196  
  4.1197    # Now try to locate executable using which
  4.1198    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1199 -  if test "x$new_path" = x; then
  4.1200 -    # Oops. Which didn't find the executable.
  4.1201 -    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1202 -    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1203 -    # argument.
  4.1204 -    path="$complete"
  4.1205 -    arguments="EOL"
  4.1206 -    new_path=`$CYGPATH -u "$path"`
  4.1207 -    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1208 +  # bat and cmd files are not always considered executable in cygwin causing which
  4.1209 +  # to not find them
  4.1210 +  if test "x$new_path" = x \
  4.1211 +           && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1212 +           && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1213 +    new_path=`$CYGPATH -u "$path"`
  4.1214 +  fi
  4.1215 +  if test "x$new_path" = x; then
  4.1216 +    # Oops. Which didn't find the executable.
  4.1217 +    # The splitting of arguments from the executable at a space might have been incorrect,
  4.1218 +    # since paths with space are more likely in Windows. Give it another try with the whole
  4.1219 +    # argument.
  4.1220 +    path="$complete"
  4.1221 +    arguments="EOL"
  4.1222 +    new_path=`$CYGPATH -u "$path"`
  4.1223 +    new_path=`$WHICH "$new_path" 2> /dev/null`
  4.1224 +    # bat and cmd files are not always considered executable in cygwin causing which
  4.1225 +    # to not find them
  4.1226 +    if test "x$new_path" = x \
  4.1227 +             && test "x`$ECHO \"$path\" | $GREP -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
  4.1228 +             && test "x`$LS \"$path\" 2>/dev/null`" != x; then
  4.1229 +      new_path=`$CYGPATH -u "$path"`
  4.1230 +    fi
  4.1231      if test "x$new_path" = x; then
  4.1232        # It's still not found. Now this is an unrecoverable error.
  4.1233        { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
  4.1234 @@ -29026,12 +29464,7 @@
  4.1235  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_freetype_FT_Init_FreeType" >&5
  4.1236  $as_echo "$ac_cv_lib_freetype_FT_Init_FreeType" >&6; }
  4.1237  if test "x$ac_cv_lib_freetype_FT_Init_FreeType" = x""yes; then :
  4.1238 -  cat >>confdefs.h <<_ACEOF
  4.1239 -#define HAVE_LIBFREETYPE 1
  4.1240 -_ACEOF
  4.1241 -
  4.1242 -  LIBS="-lfreetype $LIBS"
  4.1243 -
  4.1244 +  FREETYPE2_FOUND=true
  4.1245  else
  4.1246    as_fn_error $? "Could not find freetype2! $HELP_MSG " "$LINENO" 5
  4.1247  fi

     5.1 --- a/common/autoconf/libraries.m4	Sat Nov 03 16:15:26 2012 -0700
     5.2 +++ b/common/autoconf/libraries.m4	Sat Nov 03 16:28:14 2012 -0700
     5.3 @@ -393,7 +393,9 @@
     5.4              # AC_CHECK_LIB does not support use of cl.exe
     5.5              PREV_LDFLAGS="$LDFLAGS"
     5.6              LDFLAGS="$FREETYPE2_LIBS"
     5.7 -            AC_CHECK_LIB(freetype, FT_Init_FreeType, [], AC_MSG_ERROR([Could not find freetype2! $HELP_MSG ]))
     5.8 +            AC_CHECK_LIB(freetype, FT_Init_FreeType, 
     5.9 +                         FREETYPE2_FOUND=true, 
    5.10 +                         AC_MSG_ERROR([Could not find freetype2! $HELP_MSG ]))
    5.11              LDFLAGS="$PREV_LDFLAGS"
    5.12          fi
    5.13  fi

     6.1 --- a/common/bin/compare.sh	Sat Nov 03 16:15:26 2012 -0700
     6.2 +++ b/common/bin/compare.sh	Sat Nov 03 16:28:14 2012 -0700
     6.3 @@ -352,6 +352,29 @@
     6.4      (cd $THIS_UNZIPDIR && $UNARCHIVE $THIS_ZIP)
     6.5      (cd $OTHER_UNZIPDIR && $UNARCHIVE $OTHER_ZIP)
     6.6  
     6.7 +    # Find all archives inside and unzip them as well to compare the contents rather than
     6.8 +    # the archives.
     6.9 +    EXCEPTIONS=""
    6.10 +    for pack in $($FIND $THIS_UNZIPDIR -name "*.pack" -o -name "*.pack.gz"); do
    6.11 +        ($UNPACK200 $pack $pack.jar)
    6.12 +        # Filter out the unzipped archives from the diff below.
    6.13 +        EXCEPTIONS="$EXCEPTIONS $pack $pack.jar"
    6.14 +    done
    6.15 +    for pack in $($FIND $OTHER_UNZIPDIR -name "*.pack" -o -name "*.pack.gz"); do
    6.16 +        ($UNPACK200 $pack $pack.jar)
    6.17 +        EXCEPTIONS="$EXCEPTIONS $pack $pack.jar"
    6.18 +    done
    6.19 +    for zip in $($FIND $THIS_UNZIPDIR -name "*.jar" -o -name "*.zip"); do
    6.20 +        $MKDIR $zip.unzip
    6.21 +        (cd $zip.unzip && $UNARCHIVE $zip)
    6.22 +        EXCEPTIONS="$EXCEPTIONS $zip"
    6.23 +    done
    6.24 +    for zip in $($FIND $OTHER_UNZIPDIR -name "*.jar" -o -name "*.zip"); do
    6.25 +        $MKDIR $zip.unzip
    6.26 +        (cd $zip.unzip && $UNARCHIVE $zip)
    6.27 +        EXCEPTIONS="$EXCEPTIONS $zip"
    6.28 +    done
    6.29 +
    6.30      CONTENTS_DIFF_FILE=$WORK_DIR/$ZIP_FILE.diff
    6.31      # On solaris, there is no -q option.
    6.32      if [ "$OPENJDK_TARGET_OS" = "solaris" ]; then
    6.33 @@ -389,7 +412,7 @@
    6.34  
    6.35      $RM -f $WORK_DIR/$ZIP_FILE.diffs
    6.36      for file in $DIFFING_FILES; do
    6.37 -	if [[ "$ACCEPTED_JARZIP_CONTENTS" != *"$file"* ]]; then
    6.38 +	if [[ "$ACCEPTED_JARZIP_CONTENTS $EXCEPTIONS" != *"$file"* ]]; then
    6.39              diff_text $OTHER_UNZIPDIR/$file $THIS_UNZIPDIR/$file >> $WORK_DIR/$ZIP_FILE.diffs
    6.40  	fi
    6.41      done
    6.42 @@ -664,8 +687,8 @@
    6.43  
    6.44      # Check dependencies
    6.45      if [ -n "$LDD_CMD" ]; then
    6.46 -	(cd $FILE_WORK_DIR && $CP $OTHER_FILE . && $LDD_CMD $NAME | $AWK '{ print $1;}' | $SORT | $TEE $WORK_FILE_BASE.deps.other | $UNIQ > $WORK_FILE_BASE.deps.other.uniq)
    6.47 -	(cd $FILE_WORK_DIR && $CP $THIS_FILE . && $LDD_CMD $NAME | $AWK '{ print $1;}' | $SORT | $TEE $WORK_FILE_BASE.deps.this | $UNIQ > $WORK_FILE_BASE.deps.this.uniq)
    6.48 +	(cd $FILE_WORK_DIR && $CP $OTHER_FILE . && $LDD_CMD $NAME 2>/dev/null | $AWK '{ print $1;}' | $SORT | $TEE $WORK_FILE_BASE.deps.other | $UNIQ > $WORK_FILE_BASE.deps.other.uniq)
    6.49 +	(cd $FILE_WORK_DIR && $CP $THIS_FILE . && $LDD_CMD $NAME 2</dev/null | $AWK '{ print $1;}' | $SORT | $TEE $WORK_FILE_BASE.deps.this | $UNIQ > $WORK_FILE_BASE.deps.this.uniq)
    6.50  	(cd $FILE_WORK_DIR && $RM -f $NAME)
    6.51  	
    6.52  	LANG=C $DIFF $WORK_FILE_BASE.deps.other $WORK_FILE_BASE.deps.this > $WORK_FILE_BASE.deps.diff
    6.53 @@ -846,7 +869,12 @@
    6.54      if [ "$OPENJDK_TARGET_OS" = "windows" ]; then
    6.55          EXECS=$(cd $THIS_DIR && $FIND . -type f -name '*.exe' | $SORT | $FILTER)
    6.56      else
    6.57 -        EXECS=$(cd $THIS_DIR && $FIND . -name db -prune -o -type f -perm -100 \! \( -name '*.so' -o -name '*.dylib' -o -name '*.dll' -o -name '*.cgi' -o -name '*.jar' -o -name '*.diz' \) | $SORT | $FILTER)
    6.58 +        EXECS=$(cd $THIS_DIR && $FIND . -name db -prune -o -type f -perm -100 \! \
    6.59 +            \( -name '*.so' -o -name '*.dylib' -o -name '*.dll' -o -name '*.cgi' \
    6.60 +            -o -name '*.jar' -o -name '*.diz' -o -name 'jcontrol' -o -name '*.properties' \
    6.61 +            -o -name '*.data' -o -name '*.bfc' -o -name '*.src' -o -name '*.txt' \
    6.62 +            -o -name '*.cfg' -o -name 'meta-index' -o -name '*.properties.ja' \
    6.63 +            -o -name 'classlist' \) | $SORT | $FILTER)
    6.64      fi
    6.65  
    6.66      if [ -n "$EXECS" ]; then
    6.67 @@ -1022,6 +1050,7 @@
    6.68  if [ -d "$THIS/deploy/j2sdk-image" ]; then
    6.69      THIS_J2SDK="$THIS/deploy/j2sdk-image"
    6.70      THIS_J2RE="$THIS/deploy/j2re-image"
    6.71 +    echo "Comparing deploy images"
    6.72  elif [ -d "$THIS/images/j2sdk-image" ]; then
    6.73      THIS_J2SDK="$THIS/images/j2sdk-image"
    6.74      THIS_J2RE="$THIS/images/j2re-image"

     7.1 --- a/common/bin/compare_exceptions.sh.incl	Sat Nov 03 16:15:26 2012 -0700
     7.2 +++ b/common/bin/compare_exceptions.sh.incl	Sat Nov 03 16:28:14 2012 -0700
     7.3 @@ -282,6 +282,14 @@
     7.4  ./jre/lib/i386/libunpack.so
     7.5  ./jre/lib/i386/libverify.so
     7.6  ./jre/lib/i386/libzip.so
     7.7 +./jre/lib/i386/libdeploy.so
     7.8 +./jre/lib/i386/libjavaplugin.so
     7.9 +./jre/lib/i386/libjavaplugin_jni.so
    7.10 +./jre/lib/i386/libjavaplugin_nscp.so
    7.11 +./jre/lib/i386/libjavaplugin_oji.so
    7.12 +./jre/lib/i386/libnpjp2.so
    7.13 +./jre/plugin/i386/ns4/libjavaplugin.so
    7.14 +./jre/plugin/i386/ns7/libjavaplugin_oji.so
    7.15  ./jre/lib/i386/server/libjvm.so
    7.16  ./bin/appletviewer
    7.17  ./bin/extcheck
    7.18 @@ -293,6 +301,7 @@
    7.19  ./bin/javadoc
    7.20  ./bin/javah
    7.21  ./bin/javap
    7.22 +./bin/javaws
    7.23  ./bin/jcmd
    7.24  ./bin/jconsole
    7.25  ./bin/jdb
    7.26 @@ -322,6 +331,8 @@
    7.27  ./bin/wsimport
    7.28  ./bin/xjc
    7.29  ./jre/bin/java
    7.30 +./jre/bin/java_vm
    7.31 +./jre/bin/javaws
    7.32  ./jre/bin/keytool
    7.33  ./jre/bin/orbd
    7.34  ./jre/bin/pack200
    7.35 @@ -561,6 +572,14 @@
    7.36  ./jre/lib/sparc/libunpack.so
    7.37  ./jre/lib/sparc/libverify.so
    7.38  ./jre/lib/sparc/libzip.so
    7.39 +./jre/lib/sparc/libdeploy.so
    7.40 +./jre/lib/sparc/libjavaplugin.so
    7.41 +./jre/lib/sparc/libjavaplugin_jni.so
    7.42 +./jre/lib/sparc/libjavaplugin_nscp.so
    7.43 +./jre/lib/sparc/libjavaplugin_oji.so
    7.44 +./jre/lib/sparc/libnpjp2.so
    7.45 +./jre/plugin/sparc/ns4/libjavaplugin.so
    7.46 +./jre/plugin/sparc/ns7/libjavaplugin_oji.so
    7.47  ./jre/lib/sparc/server/libjvm.so
    7.48  ./bin/appletviewer
    7.49  ./bin/extcheck
    7.50 @@ -572,6 +591,7 @@
    7.51  ./bin/javadoc
    7.52  ./bin/javah
    7.53  ./bin/javap
    7.54 +./bin/javaws
    7.55  ./bin/jcmd
    7.56  ./bin/jconsole
    7.57  ./bin/jdb
    7.58 @@ -601,6 +621,8 @@
    7.59  ./bin/wsimport
    7.60  ./bin/xjc
    7.61  ./jre/bin/java
    7.62 +./jre/bin/java_vm
    7.63 +./jre/bin/javaws
    7.64  ./jre/bin/keytool
    7.65  ./jre/bin/orbd
    7.66  ./jre/bin/pack200

     8.1 --- a/common/makefiles/JavaCompilation.gmk	Sat Nov 03 16:15:26 2012 -0700
     8.2 +++ b/common/makefiles/JavaCompilation.gmk	Sat Nov 03 16:28:14 2012 -0700
     8.3 @@ -480,19 +480,24 @@
     8.4          $1_SJAVAC:=$$(word 1,$$($1_JAVAC)) -cp $$(word 3,$$($1_JAVAC)) com.sun.tools.sjavac.Main
     8.5  
     8.6          # Set the $1_REMOTE to spawn a background javac server.
     8.7 -        $1_REMOTE:=--server:portfile=$$($1_SJAVAC_PORTFILE),poolsize=$(SJAVAC_SERVER_CORES),id=$1,sjavac=$$(subst $$(SPACE),%20,$$(subst $$(COMMA),%2C,$$(strip $$($1_SERVER_JVM) $$($1_SJAVAC))))
     8.8 +        $1_REMOTE:=--server:portfile=$$($1_SJAVAC_PORTFILE),id=$1,sjavac=$$(subst $$(SPACE),%20,$$(subst $$(COMMA),%2C,$$(strip $$($1_SERVER_JVM) $$($1_SJAVAC))))
     8.9  
    8.10          $$($1_BIN)/javac_state: $$($1_SRCS) $$($1_DEPENDS)
    8.11  		$(MKDIR) -p $$(@D)
    8.12  		$$(call ListPathsSafely,$1_SRCS,\n, >> $$($1_BIN)/_the.batch.tmp)
    8.13  		$(ECHO) Compiling $1
    8.14 -		$$($1_JVM) $$($1_SJAVAC) \
    8.15 -			$$($1_REMOTE) $$($1_SJAVAC_ARGS) \
    8.16 +		($$($1_JVM) $$($1_SJAVAC) \
    8.17 +			$$($1_REMOTE) \
    8.18 +			-j $(NUM_CORES) \
    8.19  			--permit-unidentified-artifacts \
    8.20  			--permit-sources-without-package \
    8.21  			--compare-found-sources $$($1_BIN)/_the.batch.tmp \
    8.22 +			--log=$(LOG) \
    8.23 +			$$($1_SJAVAC_ARGS) \
    8.24  			$$($1_FLAGS) \
    8.25 -			-implicit:none -d $$($1_BIN) $$($1_HEADERS_ARG)
    8.26 +			$$($1_HEADERS_ARG) \
    8.27 +			-d $$($1_BIN) && \
    8.28 +			$(MV) $$($1_BIN)/_the.batch.tmp $$($1_BIN)/_the.batch)
    8.29      else
    8.30          # Using plain javac to batch compile everything.
    8.31          $1 := $$($1_ALL_COPY_TARGETS) $$($1_ALL_COPY_CLEAN_TARGETS) $$($1_BIN)/_the.batch