configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc extra_mpfr_configure_flags extra_mpc_gmp_configure_flags extra_mpc_mpfr_configure_flags stage1_ldflags stage1_libs poststage1_ldflags poststage1_libs ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir compare_exclusions LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-build-with-cxx build with C++ compiler instead of C compiler
 939   --disable-ppl-version-check    disable check for PPL version
 940   --disable-cloog-version-check  disable check for CLooG version
 941   --enable-stage1-languages[=all]   choose additional languages to build during
 942                           stage1.  Mostly useful for compiler development.
 943   --enable-objc-gc        enable use of Boehm's garbage collector with the
 944                           GNU Objective-C runtime
 945   --enable-bootstrap      enable bootstrapping [yes if native build]
 946   --enable-serial-[{host,target,build}-]configure
 947                           force sequential configuration of
 948                           sub-packages for the host, target or build
 949                           machine, or all sub-packages
 950   --enable-maintainer-mode enable make rules and dependencies not useful
 951                           (and sometimes confusing) to the casual installer
 952   --enable-stage1-checking[=all]   choose additional checking for stage1
 953                           of the compiler
 954   --enable-werror         enable -Werror in bootstrap stage2 and later
 955
 956 Optional Packages:
 957   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 958   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 959   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 960   --with-mpc=PATH        specify prefix directory for installed MPC package.
 961                           Equivalent to --with-mpc-include=PATH/include
 962                           plus --with-mpc-lib=PATH/lib
 963   --with-mpc-include=PATH
 964                           specify directory for installed MPC include files
 965   --with-mpc-lib=PATH    specify directory for the installed MPC library
 966   --with-mpfr-dir=PATH    this option has been REMOVED
 967   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 968                           Equivalent to --with-mpfr-include=PATH/include
 969                           plus --with-mpfr-lib=PATH/lib
 970   --with-mpfr-include=PATH
 971                           specify directory for installed MPFR include files
 972   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 973   --with-gmp-dir=PATH     this option has been REMOVED
 974   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 975                           Equivalent to --with-gmp-include=PATH/include
 976                           plus --with-gmp-lib=PATH/lib
 977   --with-gmp-include=PATH specify directory for installed GMP include files
 978   --with-gmp-lib=PATH     specify directory for the installed GMP library
 979   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 980                           when linking with PPL
 981   --with-stage1-ldflags=FLAGS Linker flags for stage1
 982   -with-stage1-libs=LIBS      Libraries for stage1
 983   --with-boot-ldflags=FLAGS Linker flags for stage2 and later
 984   --with-boot-libs=LIBS     Libraries for stage2 and later
 985 if test "$withval" = "no" -o "$withval" = "yes"; then
 986    poststage1_libs=
 987  else
 988   poststage1_libs=$withval
 989  fi
 990   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 991                           Equivalent to --with-ppl-include=PATH/include
 992                           plus --with-ppl-lib=PATH/lib
 993   --with-ppl-include=PATH Specify directory for installed PPL include files
 994   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 995   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 996                           Equivalent to --with-cloog-include=PATH/include
 997                           plus --with-cloog-lib=PATH/lib
 998   --with-cloog-include=PATH Specify directory for installed CLooG include files
 999   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
1000   --with-build-sysroot=SYSROOT
1001                           use sysroot as the system root during the build
1002   --with-debug-prefix-map='A=B C=D ...'
1003                              map A to B, C to D ... in debug information
1004   --with-build-time-tools=PATH
1005                           use given path to find target tools during the build
1006   --with-datarootdir      use datarootdir as the data root directory.
1007   --with-docdir           install documentation in this directory.
1008   --with-pdfdir           install pdf in this directory.
1009   --with-htmldir          install html in this directory.
1010
1011 Some influential environment variables:
1012   CC          C compiler command
1013   CFLAGS      C compiler flags
1014   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1015               nonstandard directory <lib dir>
1016   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1017               headers in a nonstandard directory <include dir>
1018   CXX         C++ compiler command
1019   CXXFLAGS    C++ compiler flags
1020   AR          AR for the host
1021   AS          AS for the host
1022   DLLTOOL     DLLTOOL for the host
1023   LD          LD for the host
1024   LIPO        LIPO for the host
1025   NM          NM for the host
1026   RANLIB      RANLIB for the host
1027   STRIP       STRIP for the host
1028   WINDRES     WINDRES for the host
1029   WINDMC      WINDMC for the host
1030   OBJCOPY     OBJCOPY for the host
1031   OBJDUMP     OBJDUMP for the host
1032   CC_FOR_TARGET
1033               CC for the target
1034   CXX_FOR_TARGET
1035               CXX for the target
1036   GCC_FOR_TARGET
1037               GCC for the target
1038   GCJ_FOR_TARGET
1039               GCJ for the target
1040   GFORTRAN_FOR_TARGET
1041               GFORTRAN for the target
1042   AR_FOR_TARGET
1043               AR for the target
1044   AS_FOR_TARGET
1045               AS for the target
1046   DLLTOOL_FOR_TARGET
1047               DLLTOOL for the target
1048   LD_FOR_TARGET
1049               LD for the target
1050   LIPO_FOR_TARGET
1051               LIPO for the target
1052   NM_FOR_TARGET
1053               NM for the target
1054   OBJDUMP_FOR_TARGET
1055               OBJDUMP for the target
1056   RANLIB_FOR_TARGET
1057               RANLIB for the target
1058   STRIP_FOR_TARGET
1059               STRIP for the target
1060   WINDRES_FOR_TARGET
1061               WINDRES for the target
1062   WINDMC_FOR_TARGET
1063               WINDMC for the target
1064
1065 Use these variables to override the choices made by `configure' or to help
1066 it to find libraries and programs with nonstandard names/locations.
1067
1068 _ACEOF
1069 fi
1070
1071 if test "$ac_init_help" = "recursive"; then
1072   # If there are subdirs, report their specific --help.
1073   ac_popdir=`pwd`
1074   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1075     test -d $ac_dir || continue
1076     ac_builddir=.
1077
1078 if test "$ac_dir" != .; then
1079   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1080   # A "../" for each directory in $ac_dir_suffix.
1081   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1082 else
1083   ac_dir_suffix= ac_top_builddir=
1084 fi
1085
1086 case $srcdir in
1087   .)  # No --srcdir option.  We are building in place.
1088     ac_srcdir=.
1089     if test -z "$ac_top_builddir"; then
1090        ac_top_srcdir=.
1091     else
1092        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1093     fi ;;
1094   [\\/]* | ?:[\\/]* )  # Absolute path.
1095     ac_srcdir=$srcdir$ac_dir_suffix;
1096     ac_top_srcdir=$srcdir ;;
1097   *) # Relative path.
1098     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1099     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1100 esac
1101
1102 # Do not use `cd foo && pwd` to compute absolute paths, because
1103 # the directories may not exist.
1104 case `pwd` in
1105 .) ac_abs_builddir="$ac_dir";;
1106 *)
1107   case "$ac_dir" in
1108   .) ac_abs_builddir=`pwd`;;
1109   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1110   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1111   esac;;
1112 esac
1113 case $ac_abs_builddir in
1114 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1115 *)
1116   case ${ac_top_builddir}. in
1117   .) ac_abs_top_builddir=$ac_abs_builddir;;
1118   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1119   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1120   esac;;
1121 esac
1122 case $ac_abs_builddir in
1123 .) ac_abs_srcdir=$ac_srcdir;;
1124 *)
1125   case $ac_srcdir in
1126   .) ac_abs_srcdir=$ac_abs_builddir;;
1127   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1128   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1129   esac;;
1130 esac
1131 case $ac_abs_builddir in
1132 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1133 *)
1134   case $ac_top_srcdir in
1135   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1136   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1137   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1138   esac;;
1139 esac
1140
1141     cd $ac_dir
1142     # Check for guested configure; otherwise get Cygnus style configure.
1143     if test -f $ac_srcdir/configure.gnu; then
1144       echo
1145       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1146     elif test -f $ac_srcdir/configure; then
1147       echo
1148       $SHELL $ac_srcdir/configure  --help=recursive
1149     elif test -f $ac_srcdir/configure.ac ||
1150            test -f $ac_srcdir/configure.in; then
1151       echo
1152       $ac_configure --help
1153     else
1154       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1155     fi
1156     cd $ac_popdir
1157   done
1158 fi
1159
1160 test -n "$ac_init_help" && exit 0
1161 if $ac_init_version; then
1162   cat <<\_ACEOF
1163
1164 Copyright (C) 2003 Free Software Foundation, Inc.
1165 This configure script is free software; the Free Software Foundation
1166 gives unlimited permission to copy, distribute and modify it.
1167 _ACEOF
1168   exit 0
1169 fi
1170 exec 5>config.log
1171 cat >&5 <<_ACEOF
1172 This file contains any messages produced by compilers while
1173 running configure, to aid debugging if configure makes a mistake.
1174
1175 It was created by $as_me, which was
1176 generated by GNU Autoconf 2.59.  Invocation command line was
1177
1178   $ $0 $@
1179
1180 _ACEOF
1181 {
1182 cat <<_ASUNAME
1183 ## --------- ##
1184 ## Platform. ##
1185 ## --------- ##
1186
1187 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1188 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1189 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1190 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1191 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1192
1193 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1194 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1195
1196 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1197 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1198 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1199 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1200 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1201 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1202 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1203
1204 _ASUNAME
1205
1206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1207 for as_dir in $PATH
1208 do
1209   IFS=$as_save_IFS
1210   test -z "$as_dir" && as_dir=.
1211   echo "PATH: $as_dir"
1212 done
1213
1214 } >&5
1215
1216 cat >&5 <<_ACEOF
1217
1218
1219 ## ----------- ##
1220 ## Core tests. ##
1221 ## ----------- ##
1222
1223 _ACEOF
1224
1225
1226 # Keep a trace of the command line.
1227 # Strip out --no-create and --no-recursion so they do not pile up.
1228 # Strip out --silent because we don't want to record it for future runs.
1229 # Also quote any args containing shell meta-characters.
1230 # Make two passes to allow for proper duplicate-argument suppression.
1231 ac_configure_args=
1232 ac_configure_args0=
1233 ac_configure_args1=
1234 ac_sep=
1235 ac_must_keep_next=false
1236 for ac_pass in 1 2
1237 do
1238   for ac_arg
1239   do
1240     case $ac_arg in
1241     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1242     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1243     | -silent | --silent | --silen | --sile | --sil)
1244       continue ;;
1245     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1246       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1247     esac
1248     case $ac_pass in
1249     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1250     2)
1251       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1252       if test $ac_must_keep_next = true; then
1253         ac_must_keep_next=false # Got value, back to normal.
1254       else
1255         case $ac_arg in
1256           *=* | --config-cache | -C | -disable-* | --disable-* \
1257           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1258           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1259           | -with-* | --with-* | -without-* | --without-* | --x)
1260             case "$ac_configure_args0 " in
1261               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1262             esac
1263             ;;
1264           -* ) ac_must_keep_next=true ;;
1265         esac
1266       fi
1267       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1268       # Get rid of the leading space.
1269       ac_sep=" "
1270       ;;
1271     esac
1272   done
1273 done
1274 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1275 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1276
1277 # When interrupted or exit'd, cleanup temporary files, and complete
1278 # config.log.  We remove comments because anyway the quotes in there
1279 # would cause problems or look ugly.
1280 # WARNING: Be sure not to use single quotes in there, as some shells,
1281 # such as our DU 5.0 friend, will then `close' the trap.
1282 trap 'exit_status=$?
1283   # Save into config.log some information that might help in debugging.
1284   {
1285     echo
1286
1287     cat <<\_ASBOX
1288 ## ---------------- ##
1289 ## Cache variables. ##
1290 ## ---------------- ##
1291 _ASBOX
1292     echo
1293     # The following way of writing the cache mishandles newlines in values,
1294 {
1295   (set) 2>&1 |
1296     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1297     *ac_space=\ *)
1298       sed -n \
1299         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1300           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1301       ;;
1302     *)
1303       sed -n \
1304         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1305       ;;
1306     esac;
1307 }
1308     echo
1309
1310     cat <<\_ASBOX
1311 ## ----------------- ##
1312 ## Output variables. ##
1313 ## ----------------- ##
1314 _ASBOX
1315     echo
1316     for ac_var in $ac_subst_vars
1317     do
1318       eval ac_val=$`echo $ac_var`
1319       echo "$ac_var='"'"'$ac_val'"'"'"
1320     done | sort
1321     echo
1322
1323     if test -n "$ac_subst_files"; then
1324       cat <<\_ASBOX
1325 ## ------------- ##
1326 ## Output files. ##
1327 ## ------------- ##
1328 _ASBOX
1329       echo
1330       for ac_var in $ac_subst_files
1331       do
1332         eval ac_val=$`echo $ac_var`
1333         echo "$ac_var='"'"'$ac_val'"'"'"
1334       done | sort
1335       echo
1336     fi
1337
1338     if test -s confdefs.h; then
1339       cat <<\_ASBOX
1340 ## ----------- ##
1341 ## confdefs.h. ##
1342 ## ----------- ##
1343 _ASBOX
1344       echo
1345       sed "/^$/d" confdefs.h | sort
1346       echo
1347     fi
1348     test "$ac_signal" != 0 &&
1349       echo "$as_me: caught signal $ac_signal"
1350     echo "$as_me: exit $exit_status"
1351   } >&5
1352   rm -f core *.core &&
1353   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1354     exit $exit_status
1355      ' 0
1356 for ac_signal in 1 2 13 15; do
1357   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1358 done
1359 ac_signal=0
1360
1361 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1362 rm -rf conftest* confdefs.h
1363 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1364 echo >confdefs.h
1365
1366 # Predefined preprocessor variables.
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_NAME "$PACKAGE_NAME"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1380 _ACEOF
1381
1382
1383 cat >>confdefs.h <<_ACEOF
1384 #define PACKAGE_STRING "$PACKAGE_STRING"
1385 _ACEOF
1386
1387
1388 cat >>confdefs.h <<_ACEOF
1389 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1390 _ACEOF
1391
1392
1393 # Let the site file select an alternate cache file if it wants to.
1394 # Prefer explicitly selected file to automatically selected ones.
1395 if test -z "$CONFIG_SITE"; then
1396   if test "x$prefix" != xNONE; then
1397     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1398   else
1399     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1400   fi
1401 fi
1402 for ac_site_file in $CONFIG_SITE; do
1403   if test -r "$ac_site_file"; then
1404     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1405 echo "$as_me: loading site script $ac_site_file" >&6;}
1406     sed 's/^/| /' "$ac_site_file" >&5
1407     . "$ac_site_file"
1408   fi
1409 done
1410
1411 if test -r "$cache_file"; then
1412   # Some versions of bash will fail to source /dev/null (special
1413   # files actually), so we avoid doing that.
1414   if test -f "$cache_file"; then
1415     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1416 echo "$as_me: loading cache $cache_file" >&6;}
1417     case $cache_file in
1418       [\\/]* | ?:[\\/]* ) . $cache_file;;
1419       *)                      . ./$cache_file;;
1420     esac
1421   fi
1422 else
1423   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1424 echo "$as_me: creating cache $cache_file" >&6;}
1425   >$cache_file
1426 fi
1427
1428 # Check that the precious variables saved in the cache have kept the same
1429 # value.
1430 ac_cache_corrupted=false
1431 for ac_var in `(set) 2>&1 |
1432                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1433   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1434   eval ac_new_set=\$ac_env_${ac_var}_set
1435   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1436   eval ac_new_val="\$ac_env_${ac_var}_value"
1437   case $ac_old_set,$ac_new_set in
1438     set,)
1439       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1440 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1441       ac_cache_corrupted=: ;;
1442     ,set)
1443       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1444 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1445       ac_cache_corrupted=: ;;
1446     ,);;
1447     *)
1448       if test "x$ac_old_val" != "x$ac_new_val"; then
1449         # differences in whitespace do not lead to failure.
1450         ac_old_val_w=`echo x $ac_old_val`
1451         ac_new_val_w=`echo x $ac_new_val`
1452         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1453           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1454 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1455           ac_cache_corrupted=:
1456         else
1457           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1458 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1459           eval $ac_var=\$ac_old_val
1460         fi
1461         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1462 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1463         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1464 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1465       fi;;
1466   esac
1467   # Pass precious variables to config.status.
1468   if test "$ac_new_set" = set; then
1469     case $ac_new_val in
1470     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1471       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1472     *) ac_arg=$ac_var=$ac_new_val ;;
1473     esac
1474     case " $ac_configure_args " in
1475       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1476       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1477     esac
1478   fi
1479 done
1480 if $ac_cache_corrupted; then
1481   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1482 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1483   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1484 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1485   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1486 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1487    { (exit 1); exit 1; }; }
1488 fi
1489
1490 ac_ext=c
1491 ac_cpp='$CPP $CPPFLAGS'
1492 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1493 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1494 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519 progname=$0
1520 # if PWD already has a value, it is probably wrong.
1521 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1522
1523 # Export original configure arguments for use by sub-configures.
1524 # Quote arguments with shell meta charatcers.
1525 TOPLEVEL_CONFIGURE_ARGUMENTS=
1526 set -- "$progname" "$@"
1527 for ac_arg
1528 do
1529   case "$ac_arg" in
1530   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1531     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1532     # if the argument is of the form -foo=baz, quote the baz part only
1533     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1534   *) ;;
1535   esac
1536   # Add the quoted argument to the list.
1537   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1538 done
1539 if test "$silent" = yes; then
1540   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1541 fi
1542 # Remove the initial space we just introduced and, as these will be
1543 # expanded by make, quote '$'.
1544 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1545
1546
1547 # Find the build, host, and target systems.
1548 ac_aux_dir=
1549 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1550   if test -f $ac_dir/install-sh; then
1551     ac_aux_dir=$ac_dir
1552     ac_install_sh="$ac_aux_dir/install-sh -c"
1553     break
1554   elif test -f $ac_dir/install.sh; then
1555     ac_aux_dir=$ac_dir
1556     ac_install_sh="$ac_aux_dir/install.sh -c"
1557     break
1558   elif test -f $ac_dir/shtool; then
1559     ac_aux_dir=$ac_dir
1560     ac_install_sh="$ac_aux_dir/shtool install -c"
1561     break
1562   fi
1563 done
1564 if test -z "$ac_aux_dir"; then
1565   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1566 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1567    { (exit 1); exit 1; }; }
1568 fi
1569 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1570 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1571 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1572
1573 # Make sure we can run config.sub.
1574 $ac_config_sub sun4 >/dev/null 2>&1 ||
1575   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1576 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1577    { (exit 1); exit 1; }; }
1578
1579 echo "$as_me:$LINENO: checking build system type" >&5
1580 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1581 if test "${ac_cv_build+set}" = set; then
1582   echo $ECHO_N "(cached) $ECHO_C" >&6
1583 else
1584   ac_cv_build_alias=$build_alias
1585 test -z "$ac_cv_build_alias" &&
1586   ac_cv_build_alias=`$ac_config_guess`
1587 test -z "$ac_cv_build_alias" &&
1588   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1589 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1590    { (exit 1); exit 1; }; }
1591 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1592   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1593 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1594    { (exit 1); exit 1; }; }
1595
1596 fi
1597 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1598 echo "${ECHO_T}$ac_cv_build" >&6
1599 build=$ac_cv_build
1600 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1601 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1602 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1603
1604
1605  case ${build_alias} in
1606   "") build_noncanonical=${build} ;;
1607   *) build_noncanonical=${build_alias} ;;
1608 esac
1609
1610
1611
1612  case ${host_alias} in
1613   "") host_noncanonical=${build_noncanonical} ;;
1614   *) host_noncanonical=${host_alias} ;;
1615 esac
1616
1617
1618
1619  case ${target_alias} in
1620   "") target_noncanonical=${host_noncanonical} ;;
1621   *) target_noncanonical=${target_alias} ;;
1622 esac
1623
1624
1625
1626
1627 test "$host_noncanonical" = "$target_noncanonical" &&
1628   test "$program_prefix$program_suffix$program_transform_name" = \
1629     NONENONEs,x,x, &&
1630   program_transform_name=s,y,y,
1631
1632 echo "$as_me:$LINENO: checking host system type" >&5
1633 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1634 if test "${ac_cv_host+set}" = set; then
1635   echo $ECHO_N "(cached) $ECHO_C" >&6
1636 else
1637   ac_cv_host_alias=$host_alias
1638 test -z "$ac_cv_host_alias" &&
1639   ac_cv_host_alias=$ac_cv_build_alias
1640 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1641   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1642 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1643    { (exit 1); exit 1; }; }
1644
1645 fi
1646 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1647 echo "${ECHO_T}$ac_cv_host" >&6
1648 host=$ac_cv_host
1649 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1650 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1651 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1652
1653
1654 echo "$as_me:$LINENO: checking target system type" >&5
1655 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1656 if test "${ac_cv_target+set}" = set; then
1657   echo $ECHO_N "(cached) $ECHO_C" >&6
1658 else
1659   ac_cv_target_alias=$target_alias
1660 test "x$ac_cv_target_alias" = "x" &&
1661   ac_cv_target_alias=$ac_cv_host_alias
1662 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1663   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1664 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1665    { (exit 1); exit 1; }; }
1666
1667 fi
1668 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1669 echo "${ECHO_T}$ac_cv_target" >&6
1670 target=$ac_cv_target
1671 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1672 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1673 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1674
1675
1676 # The aliases save the names the user supplied, while $host etc.
1677 # will get canonicalized.
1678 test -n "$target_alias" &&
1679   test "$program_prefix$program_suffix$program_transform_name" = \
1680     NONENONEs,x,x, &&
1681   program_prefix=${target_alias}-
1682 test "$program_prefix" != NONE &&
1683   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1684 # Use a double $ so make ignores it.
1685 test "$program_suffix" != NONE &&
1686   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1687 # Double any \ or $.  echo might interpret backslashes.
1688 # By default was `s,x,x', remove it if useless.
1689 cat <<\_ACEOF >conftest.sed
1690 s/[\\$]/&&/g;s/;s,x,x,$//
1691 _ACEOF
1692 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1693 rm conftest.sed
1694
1695
1696
1697 # Get 'install' or 'install-sh' and its variants.
1698 # Find a good install program.  We prefer a C program (faster),
1699 # so one script is as good as another.  But avoid the broken or
1700 # incompatible versions:
1701 # SysV /etc/install, /usr/sbin/install
1702 # SunOS /usr/etc/install
1703 # IRIX /sbin/install
1704 # AIX /bin/install
1705 # AmigaOS /C/install, which installs bootblocks on floppy discs
1706 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1707 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1708 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1709 # OS/2's system install, which has a completely different semantic
1710 # ./install, which can be erroneously created by make from ./install.sh.
1711 # Reject install programs that cannot install multiple files.
1712 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1713 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1714 if test -z "$INSTALL"; then
1715 if test "${ac_cv_path_install+set}" = set; then
1716   echo $ECHO_N "(cached) $ECHO_C" >&6
1717 else
1718   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1719 for as_dir in $PATH
1720 do
1721   IFS=$as_save_IFS
1722   test -z "$as_dir" && as_dir=.
1723   # Account for people who put trailing slashes in PATH elements.
1724 case $as_dir/ in
1725   ./ | .// | /cC/* | \
1726   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1727   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1728   /usr/ucb/* ) ;;
1729   *)
1730     # OSF1 and SCO ODT 3.0 have their own names for install.
1731     # Don't use installbsd from OSF since it installs stuff as root
1732     # by default.
1733     for ac_prog in ginstall scoinst install; do
1734       for ac_exec_ext in '' $ac_executable_extensions; do
1735         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1736           if test $ac_prog = install &&
1737             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1738             # AIX install.  It has an incompatible calling convention.
1739             :
1740           elif test $ac_prog = install &&
1741             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1742             # program-specific install script used by HP pwplus--don't use.
1743             :
1744           else
1745             rm -rf conftest.one conftest.two conftest.dir
1746             echo one > conftest.one
1747             echo two > conftest.two
1748             mkdir conftest.dir
1749             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1750               test -s conftest.one && test -s conftest.two &&
1751               test -s conftest.dir/conftest.one &&
1752               test -s conftest.dir/conftest.two
1753             then
1754               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1755               break 3
1756             fi
1757           fi
1758         fi
1759       done
1760     done
1761     ;;
1762 esac
1763 done
1764
1765 rm -rf conftest.one conftest.two conftest.dir
1766
1767 fi
1768   if test "${ac_cv_path_install+set}" = set; then
1769     INSTALL=$ac_cv_path_install
1770   else
1771     # As a last resort, use the slow shell script.  Don't cache a
1772     # value for INSTALL within a source directory, because that will
1773     # break other packages using the cache if that directory is
1774     # removed, or if the value is a relative name.
1775     INSTALL=$ac_install_sh
1776   fi
1777 fi
1778 echo "$as_me:$LINENO: result: $INSTALL" >&5
1779 echo "${ECHO_T}$INSTALL" >&6
1780
1781 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1782 # It thinks the first close brace ends the variable substitution.
1783 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1784
1785 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1786
1787 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1788
1789 echo "$as_me:$LINENO: checking whether ln works" >&5
1790 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1791 if test "${acx_cv_prog_LN+set}" = set; then
1792   echo $ECHO_N "(cached) $ECHO_C" >&6
1793 else
1794   rm -f conftestdata_t
1795 echo >conftestdata_f
1796 if ln conftestdata_f conftestdata_t 2>/dev/null
1797 then
1798   acx_cv_prog_LN=ln
1799 else
1800   acx_cv_prog_LN=no
1801 fi
1802 rm -f conftestdata_f conftestdata_t
1803
1804 fi
1805 if test $acx_cv_prog_LN = no; then
1806   LN="cp"
1807   echo "$as_me:$LINENO: result: no, using $LN" >&5
1808 echo "${ECHO_T}no, using $LN" >&6
1809 else
1810   LN="$acx_cv_prog_LN"
1811   echo "$as_me:$LINENO: result: yes" >&5
1812 echo "${ECHO_T}yes" >&6
1813 fi
1814
1815 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1816 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1817 LN_S=$as_ln_s
1818 if test "$LN_S" = "ln -s"; then
1819   echo "$as_me:$LINENO: result: yes" >&5
1820 echo "${ECHO_T}yes" >&6
1821 else
1822   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1823 echo "${ECHO_T}no, using $LN_S" >&6
1824 fi
1825
1826
1827 ### we might need to use some other shell than /bin/sh for running subshells
1828 ### If we are on Windows, search for the shell.  This will permit people
1829 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1830 ### without also having to set CONFIG_SHELL.  This code will work when
1831 ### using bash, which sets OSTYPE.
1832 case "${OSTYPE}" in
1833 *win32*)
1834   if test x${CONFIG_SHELL} = x ; then
1835     if test ! -f /bin/sh ; then
1836       if test x${SHELL} != x && test -f ${SHELL} ; then
1837         CONFIG_SHELL=${SHELL}
1838         export CONFIG_SHELL
1839       else
1840         for prog in sh sh.exe bash bash.exe; do
1841           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1842           for dir in $PATH; do
1843             test -z "$dir" && dir=.
1844             if test -f $dir/$prog; then
1845               CONFIG_SHELL=$dir/$prog
1846               export CONFIG_SHELL
1847               break
1848             fi
1849           done
1850           IFS="$save_ifs"
1851           test -n "${CONFIG_SHELL}" && break
1852         done
1853       fi
1854     fi
1855   fi
1856   ;;
1857 esac
1858
1859 config_shell=${CONFIG_SHELL-/bin/sh}
1860
1861 moveifchange=${srcdir}/move-if-change
1862
1863 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1864
1865 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1866 # a relative path.
1867 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1868   INSTALL="${srcpwd}/install-sh -c"
1869 fi
1870
1871 # Set srcdir to "." if that's what it is.
1872 # This is important for multilib support.
1873 pwd=`${PWDCMD-pwd}`
1874 if test "${pwd}" = "${srcpwd}" ; then
1875   srcdir=.
1876 fi
1877
1878 topsrcdir=$srcpwd
1879
1880 extra_host_args=
1881
1882 ### To add a new directory to the tree, first choose whether it is a target
1883 ### or a host dependent tool.  Then put it into the appropriate list
1884 ### (library or tools, host or target), doing a dependency sort.
1885
1886 # Subdirs will be configured in the order listed in build_configdirs,
1887 # configdirs, or target_configdirs; see the serialization section below.
1888
1889 # Dependency sorting is only needed when *configuration* must be done in
1890 # a particular order.  In all cases a dependency should be specified in
1891 # the Makefile, whether or not it's implicitly specified here.
1892
1893 # Double entries in build_configdirs, configdirs, or target_configdirs may
1894 # cause circular dependencies and break everything horribly.
1895
1896 # these library is used by various programs built for the build
1897 # environment
1898 #
1899 build_libs="build-libiberty"
1900
1901 # these tools are built for the build environment
1902 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1903
1904 # these libraries are used by various programs built for the host environment
1905 #
1906 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1907
1908 # these tools are built for the host environment
1909 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1910 # know that we are building the simulator.
1911 # binutils, gas and ld appear in that order because it makes sense to run
1912 # "make check" in that particular order.
1913 # If --enable-gold is used, "gold" will replace "ld".
1914 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc cgen sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1915
1916 # libgcj represents the runtime libraries only used by gcj.
1917 libgcj="target-libffi \
1918         target-zlib \
1919         target-qthreads \
1920         target-libjava"
1921
1922 # these libraries are built for the target environment, and are built after
1923 # the host libraries and the host tools (which may be a cross compiler)
1924 #
1925 target_libraries="target-libgcc \
1926                 target-libiberty \
1927                 target-libgloss \
1928                 target-newlib \
1929                 target-libgomp \
1930                 target-libstdc++-v3 \
1931                 target-libmudflap \
1932                 target-libssp \
1933                 target-libgfortran \
1934                 target-boehm-gc \
1935                 ${libgcj} \
1936                 target-libobjc \
1937                 target-libada"
1938
1939 # these tools are built using the target libraries, and are intended to
1940 # run only in the target environment
1941 #
1942 # note: any program that *uses* libraries that are in the "target_libraries"
1943 # list belongs in this list.  those programs are also very likely
1944 # candidates for the "native_only" list which follows
1945 #
1946 target_tools="target-examples target-groff target-gperf target-rda"
1947
1948 ################################################################################
1949
1950 ## All tools belong in one of the four categories, and are assigned above
1951 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1952 ## is important because configure will choke if they ever get through.
1953 ## ${configdirs} is directories we build using the host tools.
1954 ## ${target_configdirs} is directories we build using the target tools.
1955 configdirs=`echo ${host_libs} ${host_tools}`
1956 target_configdirs=`echo ${target_libraries} ${target_tools}`
1957 build_configdirs=`echo ${build_libs} ${build_tools}`
1958
1959
1960
1961 ################################################################################
1962
1963 srcname="gnu development package"
1964
1965 # This gets set non-empty for some net releases of packages.
1966 appdirs=""
1967
1968 # Define is_cross_compiler to save on calls to 'test'.
1969 is_cross_compiler=
1970 if test x"${host}" = x"${target}" ; then
1971   is_cross_compiler=no
1972 else
1973   is_cross_compiler=yes
1974 fi
1975
1976 # Find the build and target subdir names.
1977
1978 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1979 # have matching libraries, they should use host libraries: Makefile.tpl
1980 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1981 # However, they still use the build modules, because the corresponding
1982 # host modules (e.g. bison) are only built for the host when bootstrap
1983 # finishes. So:
1984 # - build_subdir is where we find build modules, and never changes.
1985 # - build_libsubdir is where we find build libraries, and can be overridden.
1986
1987 # Prefix 'build-' so this never conflicts with target_subdir.
1988 build_subdir="build-${build_noncanonical}"
1989
1990 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1991 if test "${with_build_libsubdir+set}" = set; then
1992   withval="$with_build_libsubdir"
1993   build_libsubdir="$withval"
1994 else
1995   build_libsubdir="$build_subdir"
1996 fi;
1997 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1998 if ( test $srcdir = . && test -d gcc ) \
1999    || test -d $srcdir/../host-${host_noncanonical}; then
2000   host_subdir="host-${host_noncanonical}"
2001 else
2002   host_subdir=.
2003 fi
2004 # No prefix.
2005 target_subdir=${target_noncanonical}
2006
2007
2008 # Skipdirs are removed silently.
2009 skipdirs=
2010 # Noconfigdirs are removed loudly.
2011 noconfigdirs=""
2012
2013 use_gnu_ld=
2014 # Make sure we don't let GNU ld be added if we didn't want it.
2015 if test x$with_gnu_ld = xno ; then
2016   use_gnu_ld=no
2017   noconfigdirs="$noconfigdirs ld gold"
2018 fi
2019
2020 use_gnu_as=
2021 # Make sure we don't let GNU as be added if we didn't want it.
2022 if test x$with_gnu_as = xno ; then
2023   use_gnu_as=no
2024   noconfigdirs="$noconfigdirs gas"
2025 fi
2026
2027 # some tools are so dependent upon X11 that if we're not building with X,
2028 # it's not even worth trying to configure, much less build, that tool.
2029
2030 case ${with_x} in
2031   yes | "") ;; # the default value for this tree is that X11 is available
2032   no)
2033     skipdirs="${skipdirs} tk itcl libgui"
2034     # We won't be able to build gdbtk without X.
2035     enable_gdbtk=no
2036     ;;
2037   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2038 esac
2039
2040 # Some tools are only suitable for building in a "native" situation.
2041 # Remove these if host!=target.
2042 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2043
2044 # Similarly, some are only suitable for cross toolchains.
2045 # Remove these if host=target.
2046 cross_only="target-libgloss target-newlib target-opcodes"
2047
2048 case $is_cross_compiler in
2049   no) skipdirs="${skipdirs} ${cross_only}" ;;
2050   yes) skipdirs="${skipdirs} ${native_only}" ;;
2051 esac
2052
2053 # If both --with-headers and --with-libs are specified, default to
2054 # --without-newlib.
2055 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2056    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2057   if test x"${with_newlib}" = x ; then
2058     with_newlib=no
2059   fi
2060 fi
2061
2062 # Recognize --with-newlib/--without-newlib.
2063 case ${with_newlib} in
2064   no) skipdirs="${skipdirs} target-newlib" ;;
2065   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2066 esac
2067
2068 # Handle --enable-gold.
2069
2070 # Check whether --enable-gold or --disable-gold was given.
2071 if test "${enable_gold+set}" = set; then
2072   enableval="$enable_gold"
2073   ENABLE_GOLD=$enableval
2074 else
2075   ENABLE_GOLD=no
2076 fi;
2077 if test "${ENABLE_GOLD}" = "yes"; then
2078   # Check for ELF target.
2079   is_elf=no
2080   case "${target}" in
2081     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2082     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2083     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2084       case "${target}" in
2085         *-*-linux*aout* | *-*-linux*oldld*)
2086           ;;
2087         *)
2088           is_elf=yes
2089           ;;
2090       esac
2091   esac
2092
2093   if test "$is_elf" = "yes"; then
2094     # Check for target supported by gold.
2095     case "${target}" in
2096       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2097         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2098         ;;
2099     esac
2100   fi
2101 fi
2102
2103 # Configure extra directories which are host specific
2104
2105 case "${host}" in
2106   *-cygwin*)
2107     configdirs="$configdirs libtermcap" ;;
2108 esac
2109
2110 # A target can indicate whether a language isn't supported for some reason.
2111 # Only spaces may be used in this macro; not newlines or tabs.
2112 unsupported_languages=
2113
2114 # Remove more programs from consideration, based on the host or
2115 # target this usually means that a port of the program doesn't
2116 # exist yet.
2117
2118 case "${host}" in
2119   hppa*64*-*-*)
2120     noconfigdirs="$noconfigdirs byacc"
2121     ;;
2122   i[3456789]86-*-vsta)
2123     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2124     ;;
2125   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2126     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2127     ;;
2128   x86_64-*-mingw*)
2129     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2130     ;;
2131   i[3456789]86-*-mingw32*)
2132     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2133     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2134     ;;
2135   i[3456789]86-*-beos*)
2136     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2137     ;;
2138   *-*-cygwin*)
2139     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2140     ;;
2141   *-*-netbsd*)
2142     noconfigdirs="$noconfigdirs rcs"
2143     ;;
2144   ppc*-*-pe)
2145     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2146     ;;
2147   powerpc-*-beos*)
2148     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2149     ;;
2150 esac
2151
2152
2153 # Check whether --enable-libada or --disable-libada was given.
2154 if test "${enable_libada+set}" = set; then
2155   enableval="$enable_libada"
2156   ENABLE_LIBADA=$enableval
2157 else
2158   ENABLE_LIBADA=yes
2159 fi;
2160 if test "${ENABLE_LIBADA}" != "yes" ; then
2161   noconfigdirs="$noconfigdirs gnattools"
2162 fi
2163
2164 # Check whether --enable-libssp or --disable-libssp was given.
2165 if test "${enable_libssp+set}" = set; then
2166   enableval="$enable_libssp"
2167   ENABLE_LIBSSP=$enableval
2168 else
2169   ENABLE_LIBSSP=yes
2170 fi;
2171
2172 # Save it here so that, even in case of --enable-libgcj, if the Java
2173 # front-end isn't enabled, we still get libgcj disabled.
2174 libgcj_saved=$libgcj
2175 case $enable_libgcj in
2176 yes)
2177   # If we reset it here, it won't get added to noconfigdirs in the
2178   # target-specific build rules, so it will be forcibly enabled
2179   # (unless the Java language itself isn't enabled).
2180   libgcj=
2181   ;;
2182 no)
2183   # Make sure we get it printed in the list of not supported target libs.
2184   noconfigdirs="$noconfigdirs ${libgcj}"
2185   ;;
2186 esac
2187
2188
2189 # Disable libmudflap on some systems.
2190 if test x$enable_libmudflap = x ; then
2191     case "${target}" in
2192     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2193         # Enable libmudflap by default in GNU and friends.
2194         ;;
2195     *-*-freebsd*)
2196         # Enable libmudflap by default in FreeBSD.
2197         ;;
2198     *)
2199         # Disable it by default everywhere else.
2200         noconfigdirs="$noconfigdirs target-libmudflap"
2201         ;;
2202     esac
2203 fi
2204
2205 # Disable libgomp on non POSIX hosted systems.
2206 if test x$enable_libgomp = x ; then
2207     # Enable libgomp by default on hosted POSIX systems.
2208     case "${target}" in
2209     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2210         ;;
2211     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2212         ;;
2213     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2214         ;;
2215     *-*-darwin* | *-*-aix*)
2216         ;;
2217     *)
2218         noconfigdirs="$noconfigdirs target-libgomp"
2219         ;;
2220     esac
2221 fi
2222
2223 # Default libgloss CPU subdirectory.
2224 libgloss_dir="$target_cpu"
2225
2226 case "${target}" in
2227   *-*-chorusos)
2228     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2229     ;;
2230   powerpc-*-darwin*)
2231     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2232     noconfigdirs="$noconfigdirs sim target-rda"
2233     ;;
2234   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2235     noconfigdirs="$noconfigdirs ld gas gprof"
2236     noconfigdirs="$noconfigdirs sim target-rda"
2237     ;;
2238   *-*-darwin*)
2239     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2240     noconfigdirs="$noconfigdirs sim target-rda"
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     ;;
2243   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2244     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2245     ;;
2246   *-*-freebsd*)
2247     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2248     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2249         && test -f /usr/local/include/gmp.h; then
2250       with_gmp=/usr/local
2251     fi
2252
2253     # Skip some stuff that's unsupported on some FreeBSD configurations.
2254     case "${target}" in
2255       i*86-*-*) ;;
2256       alpha*-*-*) ;;
2257       *)
2258         noconfigdirs="$noconfigdirs ${libgcj}"
2259         ;;
2260     esac
2261     ;;
2262   *-*-kaos*)
2263     # Remove unsupported stuff on all kaOS configurations.
2264     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2265     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2266     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2267     noconfigdirs="$noconfigdirs target-libgloss"
2268     ;;
2269   *-*-netbsd*)
2270     # Skip some stuff on all NetBSD configurations.
2271     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2272
2273     # Skip some stuff that's unsupported on some NetBSD configurations.
2274     case "${target}" in
2275       i*86-*-netbsdelf*) ;;
2276       arm*-*-netbsdelf*) ;;
2277       *)
2278         noconfigdirs="$noconfigdirs ${libgcj}"
2279         ;;
2280     esac
2281     ;;
2282   *-*-netware*)
2283     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2284     ;;
2285   *-*-rtems*)
2286     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2287     ;;
2288     # The tpf target doesn't support gdb yet.
2289   *-*-tpf*)
2290     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2291     ;;
2292   *-*-uclinux*)
2293     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2294     ;;
2295   *-*-vxworks*)
2296     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2297     ;;
2298   alpha*-dec-osf*)
2299     # ld works, but does not support shared libraries.
2300     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2301     # gas doesn't generate exception information.
2302     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2303     ;;
2304   alpha*-*-*vms*)
2305     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2306     ;;
2307   alpha*-*-linux*)
2308     # newlib is not 64 bit ready
2309     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2310     ;;
2311   alpha*-*-*)
2312     # newlib is not 64 bit ready
2313     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2314     ;;
2315   am33_2.0-*-linux*)
2316     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2317     ;;
2318   sh-*-linux*)
2319     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2320     ;;
2321   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2322     noconfigdirs="$noconfigdirs ${libgcj}"
2323     noconfigdirs="$noconfigdirs target-examples"
2324     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2325     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2326     noconfigdirs="$noconfigdirs expect dejagnu"
2327     # the C++ libraries don't build on top of CE's C libraries
2328     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2329     noconfigdirs="$noconfigdirs target-newlib"
2330     case "${host}" in
2331       *-*-cygwin*) ;; # keep gdb and readline
2332       *) noconfigdirs="$noconfigdirs gdb readline"
2333          ;;
2334     esac
2335     libgloss_dir=wince
2336     ;;
2337   arc-*-*)
2338     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2339     ;;
2340   arm-semi-aof )
2341     ;;
2342   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2343     noconfigdirs="$noconfigdirs ${libgcj}"
2344     libgloss_dir=arm
2345     ;;
2346   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2347     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2348     libgloss_dir=arm
2349     ;;
2350   arm*-*-linux-gnueabi)
2351     noconfigdirs="$noconfigdirs target-qthreads"
2352     case ${with_newlib} in
2353       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2354     esac
2355     libgloss_dir=arm
2356     ;;
2357   arm*-*-symbianelf*)
2358     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2359     libgloss_dir=arm
2360     ;;
2361   arm-*-pe*)
2362     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2363     ;;
2364   thumb-*-coff)
2365     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2366     ;;
2367   thumb-*-elf)
2368     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2369     ;;
2370   thumb-*-pe)
2371     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2372     ;;
2373   arm-*-riscix*)
2374     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2375     ;;
2376   avr-*-*)
2377     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2378     ;;
2379   bfin-*-*)
2380     noconfigdirs="$noconfigdirs gdb"
2381     if test x${is_cross_compiler} != xno ; then
2382       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2383     fi
2384     ;;
2385   c4x-*-* | tic4x-*-*)
2386     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2387     ;;
2388   c54x*-*-* | tic54x-*-*)
2389     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2390     ;;
2391   cr16-*-*)
2392     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2393     ;;
2394   cris-*-* | crisv32-*-*)
2395     unsupported_languages="$unsupported_languages java"
2396     case "${target}" in
2397       *-*-aout)
2398         unsupported_languages="$unsupported_languages fortran"
2399         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2400       *-*-elf)
2401         noconfigdirs="$noconfigdirs target-boehm-gc";;
2402       *-*-linux*)
2403         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2404       *)
2405         unsupported_languages="$unsupported_languages fortran"
2406         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2407     esac
2408     libgloss_dir=cris
2409     ;;
2410   crx-*-*)
2411     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2412     ;;
2413   d10v-*-*)
2414     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2415     ;;
2416   d30v-*-*)
2417     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2418     ;;
2419   ep9312-*-elf | ep9312-*-coff)
2420     libgloss_dir=arm
2421     ;;
2422   fr30-*-elf*)
2423     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2424     ;;
2425   frv-*-*)
2426     noconfigdirs="$noconfigdirs ${libgcj}"
2427     ;;
2428   moxie-*-*)
2429     noconfigdirs="$noconfigdirs ${libgcj}"
2430     noconfigdirs="$noconfigdirs gprof"
2431     ;;
2432   h8300*-*-*)
2433     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2434     ;;
2435   h8500-*-*)
2436     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2437     ;;
2438   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2439     ;;
2440   hppa*64*-*-linux* | parisc*64*-*-linux*)
2441     # In this case, it's because the hppa64-linux target is for
2442     # the kernel only at this point and has no libc, and thus no
2443     # headers, crt*.o, etc., all of which are needed by these.
2444     noconfigdirs="$noconfigdirs target-zlib"
2445     ;;
2446   parisc*-*-linux* | hppa*-*-linux*)
2447     ;;
2448   hppa*-*-*elf* | \
2449   hppa*-*-lites* | \
2450   hppa*-*-openbsd* | \
2451   hppa*64*-*-*)
2452     noconfigdirs="$noconfigdirs ${libgcj}"
2453     ;;
2454   hppa*-hp-hpux11*)
2455     noconfigdirs="$noconfigdirs ld shellutils"
2456     ;;
2457   hppa*-*-pro*)
2458     libgloss_dir=pa
2459     ;;
2460   hppa*-*-*)
2461     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2462     # build on HP-UX 10.20.
2463     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2464     ;;
2465   i960-*-*)
2466     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2467     ;;
2468   ia64*-*-elf*)
2469     # No gdb support yet.
2470     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2471     ;;
2472   ia64*-**-hpux*)
2473     # No gdb or ld support yet.
2474     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2475     ;;
2476   ia64*-*-*vms*)
2477     # No gdb or ld support yet.
2478     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2479     ;;
2480   i370-*-opened*)
2481     ;;
2482   i[3456789]86-*-coff | i[3456789]86-*-elf)
2483     noconfigdirs="$noconfigdirs ${libgcj}"
2484     libgloss_dir=i386
2485     ;;
2486   i[3456789]86-*-linux*)
2487     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2488     # not build java stuff by default.
2489     case "${target}" in
2490       *-*-*libc1*)
2491         noconfigdirs="$noconfigdirs ${libgcj}";;
2492     esac
2493
2494     # This section makes it possible to build newlib natively on linux.
2495     # If we are using a cross compiler then don't configure newlib.
2496     if test x${is_cross_compiler} != xno ; then
2497       noconfigdirs="$noconfigdirs target-newlib"
2498     fi
2499     noconfigdirs="$noconfigdirs target-libgloss"
2500     # If we are not using a cross compiler, do configure newlib.
2501     # Note however, that newlib will only be configured in this situation
2502     # if the --with-newlib option has been given, because otherwise
2503     # 'target-newlib' will appear in skipdirs.
2504     ;;
2505   i[3456789]86-*-mingw32*)
2506     target_configdirs="$target_configdirs target-winsup"
2507     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2508     ;;
2509   x86_64-*-mingw*)
2510     target_configdirs="$target_configdirs target-winsup"
2511     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2512     ;;
2513   *-*-cygwin*)
2514     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2515     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2516     # always build newlib if winsup directory is present.
2517     if test -d "$srcdir/winsup/cygwin"; then
2518       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2519     elif test -d "$srcdir/newlib"; then
2520       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2521     fi
2522     ;;
2523   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2524   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2525     ;;
2526   i[3456789]86-*-pe)
2527     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2528     ;;
2529   i[3456789]86-*-sco3.2v5*)
2530     # The linker does not yet know about weak symbols in COFF,
2531     # and is not configured to handle mixed ELF and COFF.
2532     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2533     ;;
2534   i[3456789]86-*-sco*)
2535     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2536     ;;
2537   i[3456789]86-*-solaris2*)
2538     noconfigdirs="$noconfigdirs target-libgloss"
2539     ;;
2540   i[3456789]86-*-sysv4*)
2541     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2542     ;;
2543   i[3456789]86-*-beos*)
2544     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2545     ;;
2546   i[3456789]86-*-rdos*)
2547     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2548     ;;
2549   m32r-*-*)
2550     noconfigdirs="$noconfigdirs ${libgcj}"
2551     ;;
2552   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2553     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2554     libgloss_dir=m68hc11
2555     ;;
2556   m68k-*-elf*)
2557     noconfigdirs="$noconfigdirs ${libgcj}"
2558     ;;
2559   m68k-*-coff*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     ;;
2562   m68*-*-* | fido-*-*)
2563     libgloss_dir=m68k
2564     ;;
2565   mcore-*-pe*)
2566   # The EPOC C++ environment does not support exceptions or rtti,
2567   # and so building libstdc++-v3 tends not to always work.
2568     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2569     ;;
2570   mmix-*-*)
2571     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2572     unsupported_languages="$unsupported_languages fortran java"
2573     ;;
2574   mn10200-*-*)
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     ;;
2577   mn10300-*-*)
2578     noconfigdirs="$noconfigdirs ${libgcj}"
2579     ;;
2580   mt-*-*)
2581     noconfigdirs="$noconfigdirs sim"
2582     ;;
2583   powerpc-*-aix*)
2584     # copied from rs6000-*-* entry
2585     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2586     ;;
2587   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2588     target_configdirs="$target_configdirs target-winsup"
2589     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2590     # always build newlib.
2591     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2592     ;;
2593     # This is temporary until we can link against shared libraries
2594   powerpcle-*-solaris*)
2595     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2596     libgloss_dir=rs6000
2597     ;;
2598   powerpc-*-beos*)
2599     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2600     ;;
2601   powerpc-*-eabi)
2602     noconfigdirs="$noconfigdirs ${libgcj}"
2603     libgloss_dir=rs6000
2604     ;;
2605   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2606     libgloss_dir=rs6000
2607     ;;
2608   rs6000-*-lynxos*)
2609     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2610     ;;
2611   rs6000-*-aix*)
2612     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2613     ;;
2614   rs6000-*-*)
2615     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2616     ;;
2617   m68k-apollo-*)
2618     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2619     ;;
2620   mips*-sde-elf*)
2621     skipdirs="$skipdirs target-libiberty"
2622     noconfigdirs="$noconfigdirs ${libgcj}"
2623     if test x$with_newlib = xyes; then
2624       noconfigdirs="$noconfigdirs gprof"
2625     fi
2626     libgloss_dir=mips
2627     ;;
2628   mips*-*-irix5*)
2629     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2630     ;;
2631   mips*-*-irix6*)
2632     # Linking libjava exceeds command-line length limits on at least
2633     # IRIX 6.2, but not on IRIX 6.5.
2634     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2635     # <oldham@codesourcery.com>
2636     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2637     ;;
2638   mips*-*-bsd*)
2639     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2640     ;;
2641   mips*-*-linux*)
2642     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2643     ;;
2644   mips*-*-*)
2645     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2646     libgloss_dir=mips
2647     ;;
2648   romp-*-*)
2649     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2650     ;;
2651   sh-*-* | sh64-*-*)
2652     case "${host}" in
2653       i[3456789]86-*-vsta) ;; # don't add gprof back in
2654       i[3456789]86-*-go32*) ;; # don't add gprof back in
2655       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2656       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2657     esac
2658     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2659     ;;
2660   sparclet-*-aout* | sparc86x-*-*)
2661     libgloss_dir=sparc
2662     ;;
2663   sparc-*-elf*)
2664     noconfigdirs="$noconfigdirs ${libgcj}"
2665     ;;
2666   sparc64-*-elf*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     libgloss_dir=sparc
2669     ;;
2670   sparclite-*-*)
2671     noconfigdirs="$noconfigdirs ${libgcj}"
2672     libgloss_dir=sparc
2673     ;;
2674   sparc-*-sunos4*)
2675     noconfigdirs="$noconfigdirs ${libgcj}"
2676     if test x${is_cross_compiler} != xno ; then
2677            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2678     else
2679            use_gnu_ld=no
2680     fi
2681     ;;
2682   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2683     noconfigdirs="$noconfigdirs ${libgcj}"
2684     ;;
2685   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2686     ;;
2687   v810-*-*)
2688     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2689     ;;
2690   v850-*-*)
2691     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2692     ;;
2693   v850e-*-*)
2694     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2695     ;;
2696   v850ea-*-*)
2697     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2698     ;;
2699   vax-*-vms)
2700     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2701     ;;
2702   vax-*-*)
2703     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2704     ;;
2705   xtensa*-*-*)
2706     noconfigdirs="$noconfigdirs ${libgcj}"
2707     ;;
2708   ip2k-*-*)
2709     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2710     ;;
2711   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2712     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2713     ;;
2714   *-*-lynxos*)
2715     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2716     ;;
2717   *-*-*)
2718     noconfigdirs="$noconfigdirs ${libgcj}"
2719     ;;
2720 esac
2721
2722 # If we aren't building newlib, then don't build libgloss, since libgloss
2723 # depends upon some newlib header files.
2724 case "${noconfigdirs}" in
2725   *target-libgloss*) ;;
2726   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2727 esac
2728
2729 # Work in distributions that contain no compiler tools, like Autoconf.
2730 tentative_cc=""
2731 host_makefile_frag=/dev/null
2732 if test -d ${srcdir}/config ; then
2733 case "${host}" in
2734   m68k-hp-hpux*)
2735     # Avoid "too much defining" errors from HPUX compiler.
2736     tentative_cc="cc -Wp,-H256000"
2737     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2738     # If it's HP/UX ar, this should be harmless.
2739     RANLIB="ar ts"
2740     ;;
2741   m68k-apollo-sysv*)
2742     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2743     ;;
2744   m68k-apollo-bsd*)
2745     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2746     # chokes on bfd, the compiler won't let you assign integers to enums, and
2747     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2748     # the apollo compiler" (the preferred version of GCC could be called cc,
2749     # or whatever), but I'm not sure leaving CC as cc is any better...
2750     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2751     # Used to have BISON=yacc.
2752     tentative_cc=gcc
2753     ;;
2754   m88k-dg-dgux*)
2755     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2756     ;;
2757   m88k-harris-cxux*)
2758     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2759     tentative_cc="cc -Xa"
2760     host_makefile_frag="config/mh-cxux"
2761     ;;
2762   m88k-motorola-sysv*)
2763     ;;
2764   mips*-dec-ultrix*)
2765     tentative_cc="cc -Wf,-XNg1000"
2766     host_makefile_frag="config/mh-decstation"
2767     ;;
2768   mips*-nec-sysv4*)
2769     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2770     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2771     host_makefile_frag="config/mh-necv4"
2772     ;;
2773   mips*-sgi-irix4*)
2774     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2775     # environment.  Also bump switch table size so that cp-parse will
2776     # compile.  Bump string length limit so linker builds.
2777     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2778     ;;
2779   mips*-*-sysv4*)
2780     host_makefile_frag="config/mh-sysv4"
2781     ;;
2782   mips*-*-sysv*)
2783     # This is for a MIPS running RISC/os 4.52C.
2784
2785     # This is needed for GDB, but needs to be in the top-level make because
2786     # if a library is compiled with the bsd headers and gets linked with the
2787     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2788     # a different size).
2789     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2790     # known except to select the sysv environment.  Could we use /proc instead?
2791     # These "sysv environments" and "bsd environments" often end up being a pain.
2792     #
2793     # This is not part of CFLAGS because perhaps not all C compilers have this
2794     # option.
2795     tentative_cc="cc -systype sysv"
2796     ;;
2797   i370-ibm-opened*)
2798     tentative_cc="c89"
2799     ;;
2800   i[3456789]86-*-sysv5*)
2801     host_makefile_frag="config/mh-sysv5"
2802     ;;
2803   i[3456789]86-*-dgux*)
2804     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2805     host_makefile_frag="config/mh-dgux386"
2806     ;;
2807   i[3456789]86-ncr-sysv4.3*)
2808     # The MetaWare compiler will generate a copyright message unless you
2809     # turn it off by adding the -Hnocopyr flag.
2810     tentative_cc="cc -Hnocopyr"
2811     ;;
2812   i[3456789]86-ncr-sysv4*)
2813     # for an NCR 3000 (i486/SVR4) system.
2814     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2815     # This compiler not only emits obnoxious copyright messages every time
2816     # you run it, but it chokes and dies on a whole bunch of GNU source
2817     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2818     tentative_cc="/usr/ccs/ATT/cc"
2819     host_makefile_frag="config/mh-ncr3000"
2820     ;;
2821   i[3456789]86-*-sco3.2v5*)
2822     ;;
2823   i[3456789]86-*-sco*)
2824     # The native C compiler botches some simple uses of const.  Unfortunately,
2825     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2826     tentative_cc="cc -Dconst="
2827     host_makefile_frag="config/mh-sco"
2828     ;;
2829   i[3456789]86-*-udk*)
2830     host_makefile_frag="config/mh-sysv5"
2831     ;;
2832   i[3456789]86-*-solaris2*)
2833     host_makefile_frag="config/mh-sysv4"
2834     ;;
2835   i[3456789]86-*-msdosdjgpp*)
2836     host_makefile_frag="config/mh-djgpp"
2837     ;;
2838   *-cygwin*)
2839
2840 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2841 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2842 echo a >cygwin-cat-check
2843 if test `cat cygwin-cat-check` == a ; then
2844   rm cygwin-cat-check
2845   echo "$as_me:$LINENO: result: yes" >&5
2846 echo "${ECHO_T}yes" >&6
2847 else
2848   rm cygwin-cat-check
2849   echo "$as_me:$LINENO: result: no" >&5
2850 echo "${ECHO_T}no" >&6
2851   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2852   Please either mount the build directory in binary mode or run the following
2853   commands before running any configure script:
2854 set -o igncr
2855 export SHELLOPTS
2856   " >&5
2857 echo "$as_me: error: The cat command does not ignore carriage return characters.
2858   Please either mount the build directory in binary mode or run the following
2859   commands before running any configure script:
2860 set -o igncr
2861 export SHELLOPTS
2862   " >&2;}
2863    { (exit 1); exit 1; }; }
2864 fi
2865
2866     host_makefile_frag="config/mh-cygwin"
2867     ;;
2868   *-mingw*)
2869     host_makefile_frag="config/mh-mingw"
2870     ;;
2871   *-interix*)
2872     host_makefile_frag="config/mh-interix"
2873     ;;
2874   vax-*-ultrix2*)
2875     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2876     tentative_cc=gcc
2877     ;;
2878   *-*-solaris2*)
2879     host_makefile_frag="config/mh-solaris"
2880     ;;
2881   m68k-sun-sunos*)
2882     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2883     # without overflowing the jump tables (-J says to use a 32 bit table)
2884     tentative_cc="cc -J"
2885     ;;
2886   hppa*-hp-hpux10*)
2887     tentative_cc="cc -Wp,-H256000"
2888     host_makefile_frag="config/mh-pa-hpux10"
2889     ;;
2890   hppa*-hp-hpux* | hppa*-*-hiux*)
2891     tentative_cc="cc -Wp,-H256000"
2892     host_makefile_frag="config/mh-pa"
2893     ;;
2894   hppa*-*)
2895     host_makefile_frag="config/mh-pa"
2896     ;;
2897   *-hp-hpux* | *-*-hiux*)
2898     tentative_cc="cc -Wp,-H256000"
2899     ;;
2900   rs6000-*-lynxos*)
2901     # /bin/cc is less than useful for our purposes.  Always use GCC
2902     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2903     host_makefile_frag="config/mh-lynxrs6k"
2904     ;;
2905   powerpc-*-darwin*)
2906     host_makefile_frag="config/mh-ppc-darwin"
2907     ;;
2908   powerpc-*-aix*)
2909     host_makefile_frag="config/mh-ppc-aix"
2910     ;;
2911   rs6000-*-aix*)
2912     host_makefile_frag="config/mh-ppc-aix"
2913     ;;
2914   *-*-lynxos*)
2915     # /bin/cc is less than useful for our purposes.  Always use GCC
2916     tentative_cc="/bin/gcc"
2917     ;;
2918   *-*-sysv4*)
2919     host_makefile_frag="config/mh-sysv4"
2920     ;;
2921   # This is placed last to prevent interfering with the cases above.
2922   i[3456789]86-*-*)
2923     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2924     host_makefile_frag="config/mh-x86omitfp"
2925     ;;
2926 esac
2927 fi
2928
2929 # If we aren't going to be using gcc, see if we can extract a definition
2930 # of CC from the fragment.
2931 # Actually, use the 'pre-extracted' version above.
2932 if test -z "${CC}" && test "${build}" = "${host}" ; then
2933   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2934   found=
2935   for dir in $PATH; do
2936     test -z "$dir" && dir=.
2937     if test -f $dir/gcc; then
2938       found=yes
2939       break
2940     fi
2941   done
2942   IFS="$save_ifs"
2943   if test -z "${found}" && test -n "${tentative_cc}" ; then
2944     CC=$tentative_cc
2945   fi
2946 fi
2947
2948 if test "${build}" != "${host}" ; then
2949   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2950   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2951   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2952   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2953   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2954   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2955   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2956   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2957   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2958   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2959   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2960   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2961 else
2962   AR_FOR_BUILD="\$(AR)"
2963   AS_FOR_BUILD="\$(AS)"
2964   CC_FOR_BUILD="\$(CC)"
2965   CXX_FOR_BUILD="\$(CXX)"
2966   GCJ_FOR_BUILD="\$(GCJ)"
2967   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2968   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2969   LD_FOR_BUILD="\$(LD)"
2970   NM_FOR_BUILD="\$(NM)"
2971   RANLIB_FOR_BUILD="\$(RANLIB)"
2972   WINDRES_FOR_BUILD="\$(WINDRES)"
2973   WINDMC_FOR_BUILD="\$(WINDMC)"
2974 fi
2975
2976 ac_ext=c
2977 ac_cpp='$CPP $CPPFLAGS'
2978 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2979 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2980 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2981 if test -n "$ac_tool_prefix"; then
2982   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2983 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2984 echo "$as_me:$LINENO: checking for $ac_word" >&5
2985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2986 if test "${ac_cv_prog_CC+set}" = set; then
2987   echo $ECHO_N "(cached) $ECHO_C" >&6
2988 else
2989   if test -n "$CC"; then
2990   ac_cv_prog_CC="$CC" # Let the user override the test.
2991 else
2992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2993 for as_dir in $PATH
2994 do
2995   IFS=$as_save_IFS
2996   test -z "$as_dir" && as_dir=.
2997   for ac_exec_ext in '' $ac_executable_extensions; do
2998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2999     ac_cv_prog_CC="${ac_tool_prefix}gcc"
3000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3001     break 2
3002   fi
3003 done
3004 done
3005
3006 fi
3007 fi
3008 CC=$ac_cv_prog_CC
3009 if test -n "$CC"; then
3010   echo "$as_me:$LINENO: result: $CC" >&5
3011 echo "${ECHO_T}$CC" >&6
3012 else
3013   echo "$as_me:$LINENO: result: no" >&5
3014 echo "${ECHO_T}no" >&6
3015 fi
3016
3017 fi
3018 if test -z "$ac_cv_prog_CC"; then
3019   ac_ct_CC=$CC
3020   # Extract the first word of "gcc", so it can be a program name with args.
3021 set dummy gcc; ac_word=$2
3022 echo "$as_me:$LINENO: checking for $ac_word" >&5
3023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3024 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3025   echo $ECHO_N "(cached) $ECHO_C" >&6
3026 else
3027   if test -n "$ac_ct_CC"; then
3028   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3029 else
3030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3031 for as_dir in $PATH
3032 do
3033   IFS=$as_save_IFS
3034   test -z "$as_dir" && as_dir=.
3035   for ac_exec_ext in '' $ac_executable_extensions; do
3036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3037     ac_cv_prog_ac_ct_CC="gcc"
3038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3039     break 2
3040   fi
3041 done
3042 done
3043
3044 fi
3045 fi
3046 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3047 if test -n "$ac_ct_CC"; then
3048   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3049 echo "${ECHO_T}$ac_ct_CC" >&6
3050 else
3051   echo "$as_me:$LINENO: result: no" >&5
3052 echo "${ECHO_T}no" >&6
3053 fi
3054
3055   CC=$ac_ct_CC
3056 else
3057   CC="$ac_cv_prog_CC"
3058 fi
3059
3060 if test -z "$CC"; then
3061   if test -n "$ac_tool_prefix"; then
3062   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3063 set dummy ${ac_tool_prefix}cc; ac_word=$2
3064 echo "$as_me:$LINENO: checking for $ac_word" >&5
3065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3066 if test "${ac_cv_prog_CC+set}" = set; then
3067   echo $ECHO_N "(cached) $ECHO_C" >&6
3068 else
3069   if test -n "$CC"; then
3070   ac_cv_prog_CC="$CC" # Let the user override the test.
3071 else
3072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3073 for as_dir in $PATH
3074 do
3075   IFS=$as_save_IFS
3076   test -z "$as_dir" && as_dir=.
3077   for ac_exec_ext in '' $ac_executable_extensions; do
3078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3079     ac_cv_prog_CC="${ac_tool_prefix}cc"
3080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3081     break 2
3082   fi
3083 done
3084 done
3085
3086 fi
3087 fi
3088 CC=$ac_cv_prog_CC
3089 if test -n "$CC"; then
3090   echo "$as_me:$LINENO: result: $CC" >&5
3091 echo "${ECHO_T}$CC" >&6
3092 else
3093   echo "$as_me:$LINENO: result: no" >&5
3094 echo "${ECHO_T}no" >&6
3095 fi
3096
3097 fi
3098 if test -z "$ac_cv_prog_CC"; then
3099   ac_ct_CC=$CC
3100   # Extract the first word of "cc", so it can be a program name with args.
3101 set dummy cc; ac_word=$2
3102 echo "$as_me:$LINENO: checking for $ac_word" >&5
3103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3104 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3105   echo $ECHO_N "(cached) $ECHO_C" >&6
3106 else
3107   if test -n "$ac_ct_CC"; then
3108   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3109 else
3110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3111 for as_dir in $PATH
3112 do
3113   IFS=$as_save_IFS
3114   test -z "$as_dir" && as_dir=.
3115   for ac_exec_ext in '' $ac_executable_extensions; do
3116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3117     ac_cv_prog_ac_ct_CC="cc"
3118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3119     break 2
3120   fi
3121 done
3122 done
3123
3124 fi
3125 fi
3126 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3127 if test -n "$ac_ct_CC"; then
3128   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3129 echo "${ECHO_T}$ac_ct_CC" >&6
3130 else
3131   echo "$as_me:$LINENO: result: no" >&5
3132 echo "${ECHO_T}no" >&6
3133 fi
3134
3135   CC=$ac_ct_CC
3136 else
3137   CC="$ac_cv_prog_CC"
3138 fi
3139
3140 fi
3141 if test -z "$CC"; then
3142   # Extract the first word of "cc", so it can be a program name with args.
3143 set dummy cc; ac_word=$2
3144 echo "$as_me:$LINENO: checking for $ac_word" >&5
3145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3146 if test "${ac_cv_prog_CC+set}" = set; then
3147   echo $ECHO_N "(cached) $ECHO_C" >&6
3148 else
3149   if test -n "$CC"; then
3150   ac_cv_prog_CC="$CC" # Let the user override the test.
3151 else
3152   ac_prog_rejected=no
3153 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3154 for as_dir in $PATH
3155 do
3156   IFS=$as_save_IFS
3157   test -z "$as_dir" && as_dir=.
3158   for ac_exec_ext in '' $ac_executable_extensions; do
3159   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3160     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3161        ac_prog_rejected=yes
3162        continue
3163      fi
3164     ac_cv_prog_CC="cc"
3165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3166     break 2
3167   fi
3168 done
3169 done
3170
3171 if test $ac_prog_rejected = yes; then
3172   # We found a bogon in the path, so make sure we never use it.
3173   set dummy $ac_cv_prog_CC
3174   shift
3175   if test $# != 0; then
3176     # We chose a different compiler from the bogus one.
3177     # However, it has the same basename, so the bogon will be chosen
3178     # first if we set CC to just the basename; use the full file name.
3179     shift
3180     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3181   fi
3182 fi
3183 fi
3184 fi
3185 CC=$ac_cv_prog_CC
3186 if test -n "$CC"; then
3187   echo "$as_me:$LINENO: result: $CC" >&5
3188 echo "${ECHO_T}$CC" >&6
3189 else
3190   echo "$as_me:$LINENO: result: no" >&5
3191 echo "${ECHO_T}no" >&6
3192 fi
3193
3194 fi
3195 if test -z "$CC"; then
3196   if test -n "$ac_tool_prefix"; then
3197   for ac_prog in cl
3198   do
3199     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3200 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3201 echo "$as_me:$LINENO: checking for $ac_word" >&5
3202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3203 if test "${ac_cv_prog_CC+set}" = set; then
3204   echo $ECHO_N "(cached) $ECHO_C" >&6
3205 else
3206   if test -n "$CC"; then
3207   ac_cv_prog_CC="$CC" # Let the user override the test.
3208 else
3209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3210 for as_dir in $PATH
3211 do
3212   IFS=$as_save_IFS
3213   test -z "$as_dir" && as_dir=.
3214   for ac_exec_ext in '' $ac_executable_extensions; do
3215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3216     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3218     break 2
3219   fi
3220 done
3221 done
3222
3223 fi
3224 fi
3225 CC=$ac_cv_prog_CC
3226 if test -n "$CC"; then
3227   echo "$as_me:$LINENO: result: $CC" >&5
3228 echo "${ECHO_T}$CC" >&6
3229 else
3230   echo "$as_me:$LINENO: result: no" >&5
3231 echo "${ECHO_T}no" >&6
3232 fi
3233
3234     test -n "$CC" && break
3235   done
3236 fi
3237 if test -z "$CC"; then
3238   ac_ct_CC=$CC
3239   for ac_prog in cl
3240 do
3241   # Extract the first word of "$ac_prog", so it can be a program name with args.
3242 set dummy $ac_prog; ac_word=$2
3243 echo "$as_me:$LINENO: checking for $ac_word" >&5
3244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3245 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3246   echo $ECHO_N "(cached) $ECHO_C" >&6
3247 else
3248   if test -n "$ac_ct_CC"; then
3249   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3250 else
3251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3252 for as_dir in $PATH
3253 do
3254   IFS=$as_save_IFS
3255   test -z "$as_dir" && as_dir=.
3256   for ac_exec_ext in '' $ac_executable_extensions; do
3257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3258     ac_cv_prog_ac_ct_CC="$ac_prog"
3259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3260     break 2
3261   fi
3262 done
3263 done
3264
3265 fi
3266 fi
3267 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3268 if test -n "$ac_ct_CC"; then
3269   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3270 echo "${ECHO_T}$ac_ct_CC" >&6
3271 else
3272   echo "$as_me:$LINENO: result: no" >&5
3273 echo "${ECHO_T}no" >&6
3274 fi
3275
3276   test -n "$ac_ct_CC" && break
3277 done
3278
3279   CC=$ac_ct_CC
3280 fi
3281
3282 fi
3283
3284
3285 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3286 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3287 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3288 See \`config.log' for more details." >&5
3289 echo "$as_me: error: no acceptable C compiler found in \$PATH
3290 See \`config.log' for more details." >&2;}
3291    { (exit 1); exit 1; }; }; }
3292
3293 # Provide some information about the compiler.
3294 echo "$as_me:$LINENO:" \
3295      "checking for C compiler version" >&5
3296 ac_compiler=`set X $ac_compile; echo $2`
3297 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3298   (eval $ac_compiler --version </dev/null >&5) 2>&5
3299   ac_status=$?
3300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3301   (exit $ac_status); }
3302 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3303   (eval $ac_compiler -v </dev/null >&5) 2>&5
3304   ac_status=$?
3305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3306   (exit $ac_status); }
3307 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3308   (eval $ac_compiler -V </dev/null >&5) 2>&5
3309   ac_status=$?
3310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3311   (exit $ac_status); }
3312
3313 cat >conftest.$ac_ext <<_ACEOF
3314 /* confdefs.h.  */
3315 _ACEOF
3316 cat confdefs.h >>conftest.$ac_ext
3317 cat >>conftest.$ac_ext <<_ACEOF
3318 /* end confdefs.h.  */
3319
3320 int
3321 main ()
3322 {
3323
3324   ;
3325   return 0;
3326 }
3327 _ACEOF
3328 ac_clean_files_save=$ac_clean_files
3329 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3330 # Try to create an executable without -o first, disregard a.out.
3331 # It will help us diagnose broken compilers, and finding out an intuition
3332 # of exeext.
3333 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3334 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3335 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3336 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3337   (eval $ac_link_default) 2>&5
3338   ac_status=$?
3339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3340   (exit $ac_status); }; then
3341   # Find the output, starting from the most likely.  This scheme is
3342 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3343 # resort.
3344
3345 # Be careful to initialize this variable, since it used to be cached.
3346 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3347 ac_cv_exeext=
3348 # b.out is created by i960 compilers.
3349 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3350 do
3351   test -f "$ac_file" || continue
3352   case $ac_file in
3353     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3354         ;;
3355     conftest.$ac_ext )
3356         # This is the source file.
3357         ;;
3358     [ab].out )
3359         # We found the default executable, but exeext='' is most
3360         # certainly right.
3361         break;;
3362     *.* )
3363         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3364         # FIXME: I believe we export ac_cv_exeext for Libtool,
3365         # but it would be cool to find out if it's true.  Does anybody
3366         # maintain Libtool? --akim.
3367         export ac_cv_exeext
3368         break;;
3369     * )
3370         break;;
3371   esac
3372 done
3373 else
3374   echo "$as_me: failed program was:" >&5
3375 sed 's/^/| /' conftest.$ac_ext >&5
3376
3377 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3378 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3379 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3380 See \`config.log' for more details." >&5
3381 echo "$as_me: error: C compiler cannot create executables
3382 See \`config.log' for more details." >&2;}
3383    { (exit 77); exit 77; }; }; }
3384 fi
3385
3386 ac_exeext=$ac_cv_exeext
3387 echo "$as_me:$LINENO: result: $ac_file" >&5
3388 echo "${ECHO_T}$ac_file" >&6
3389
3390 # Check the compiler produces executables we can run.  If not, either
3391 # the compiler is broken, or we cross compile.
3392 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3393 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3394 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3395 # If not cross compiling, check that we can run a simple program.
3396 if test "$cross_compiling" != yes; then
3397   if { ac_try='./$ac_file'
3398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3399   (eval $ac_try) 2>&5
3400   ac_status=$?
3401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3402   (exit $ac_status); }; }; then
3403     cross_compiling=no
3404   else
3405     if test "$cross_compiling" = maybe; then
3406         cross_compiling=yes
3407     else
3408         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3409 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3410 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3411 If you meant to cross compile, use \`--host'.
3412 See \`config.log' for more details." >&5
3413 echo "$as_me: error: cannot run C compiled programs.
3414 If you meant to cross compile, use \`--host'.
3415 See \`config.log' for more details." >&2;}
3416    { (exit 1); exit 1; }; }; }
3417     fi
3418   fi
3419 fi
3420 echo "$as_me:$LINENO: result: yes" >&5
3421 echo "${ECHO_T}yes" >&6
3422
3423 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3424 ac_clean_files=$ac_clean_files_save
3425 # Check the compiler produces executables we can run.  If not, either
3426 # the compiler is broken, or we cross compile.
3427 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3428 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3429 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3430 echo "${ECHO_T}$cross_compiling" >&6
3431
3432 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3433 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3434 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3435   (eval $ac_link) 2>&5
3436   ac_status=$?
3437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3438   (exit $ac_status); }; then
3439   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3440 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3441 # work properly (i.e., refer to `conftest.exe'), while it won't with
3442 # `rm'.
3443 for ac_file in conftest.exe conftest conftest.*; do
3444   test -f "$ac_file" || continue
3445   case $ac_file in
3446     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3447     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3448           export ac_cv_exeext
3449           break;;
3450     * ) break;;
3451   esac
3452 done
3453 else
3454   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3455 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3456 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3457 See \`config.log' for more details." >&5
3458 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3459 See \`config.log' for more details." >&2;}
3460    { (exit 1); exit 1; }; }; }
3461 fi
3462
3463 rm -f conftest$ac_cv_exeext
3464 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3465 echo "${ECHO_T}$ac_cv_exeext" >&6
3466
3467 rm -f conftest.$ac_ext
3468 EXEEXT=$ac_cv_exeext
3469 ac_exeext=$EXEEXT
3470 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3471 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3472 if test "${ac_cv_objext+set}" = set; then
3473   echo $ECHO_N "(cached) $ECHO_C" >&6
3474 else
3475   cat >conftest.$ac_ext <<_ACEOF
3476 /* confdefs.h.  */
3477 _ACEOF
3478 cat confdefs.h >>conftest.$ac_ext
3479 cat >>conftest.$ac_ext <<_ACEOF
3480 /* end confdefs.h.  */
3481
3482 int
3483 main ()
3484 {
3485
3486   ;
3487   return 0;
3488 }
3489 _ACEOF
3490 rm -f conftest.o conftest.obj
3491 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3492   (eval $ac_compile) 2>&5
3493   ac_status=$?
3494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3495   (exit $ac_status); }; then
3496   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3497   case $ac_file in
3498     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3499     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3500        break;;
3501   esac
3502 done
3503 else
3504   echo "$as_me: failed program was:" >&5
3505 sed 's/^/| /' conftest.$ac_ext >&5
3506
3507 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3508 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3509 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3510 See \`config.log' for more details." >&5
3511 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3512 See \`config.log' for more details." >&2;}
3513    { (exit 1); exit 1; }; }; }
3514 fi
3515
3516 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3517 fi
3518 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3519 echo "${ECHO_T}$ac_cv_objext" >&6
3520 OBJEXT=$ac_cv_objext
3521 ac_objext=$OBJEXT
3522 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3523 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3524 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3525   echo $ECHO_N "(cached) $ECHO_C" >&6
3526 else
3527   cat >conftest.$ac_ext <<_ACEOF
3528 /* confdefs.h.  */
3529 _ACEOF
3530 cat confdefs.h >>conftest.$ac_ext
3531 cat >>conftest.$ac_ext <<_ACEOF
3532 /* end confdefs.h.  */
3533
3534 int
3535 main ()
3536 {
3537 #ifndef __GNUC__
3538        choke me
3539 #endif
3540
3541   ;
3542   return 0;
3543 }
3544 _ACEOF
3545 rm -f conftest.$ac_objext
3546 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3547   (eval $ac_compile) 2>conftest.er1
3548   ac_status=$?
3549   grep -v '^ *+' conftest.er1 >conftest.err
3550   rm -f conftest.er1
3551   cat conftest.err >&5
3552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3553   (exit $ac_status); } &&
3554          { ac_try='test -z "$ac_c_werror_flag"
3555                          || test ! -s conftest.err'
3556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3557   (eval $ac_try) 2>&5
3558   ac_status=$?
3559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3560   (exit $ac_status); }; } &&
3561          { ac_try='test -s conftest.$ac_objext'
3562   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3563   (eval $ac_try) 2>&5
3564   ac_status=$?
3565   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3566   (exit $ac_status); }; }; then
3567   ac_compiler_gnu=yes
3568 else
3569   echo "$as_me: failed program was:" >&5
3570 sed 's/^/| /' conftest.$ac_ext >&5
3571
3572 ac_compiler_gnu=no
3573 fi
3574 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3575 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3576
3577 fi
3578 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3579 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3580 GCC=`test $ac_compiler_gnu = yes && echo yes`
3581 ac_test_CFLAGS=${CFLAGS+set}
3582 ac_save_CFLAGS=$CFLAGS
3583 CFLAGS="-g"
3584 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3585 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3586 if test "${ac_cv_prog_cc_g+set}" = set; then
3587   echo $ECHO_N "(cached) $ECHO_C" >&6
3588 else
3589   cat >conftest.$ac_ext <<_ACEOF
3590 /* confdefs.h.  */
3591 _ACEOF
3592 cat confdefs.h >>conftest.$ac_ext
3593 cat >>conftest.$ac_ext <<_ACEOF
3594 /* end confdefs.h.  */
3595
3596 int
3597 main ()
3598 {
3599
3600   ;
3601   return 0;
3602 }
3603 _ACEOF
3604 rm -f conftest.$ac_objext
3605 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3606   (eval $ac_compile) 2>conftest.er1
3607   ac_status=$?
3608   grep -v '^ *+' conftest.er1 >conftest.err
3609   rm -f conftest.er1
3610   cat conftest.err >&5
3611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3612   (exit $ac_status); } &&
3613          { ac_try='test -z "$ac_c_werror_flag"
3614                          || test ! -s conftest.err'
3615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3616   (eval $ac_try) 2>&5
3617   ac_status=$?
3618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3619   (exit $ac_status); }; } &&
3620          { ac_try='test -s conftest.$ac_objext'
3621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3622   (eval $ac_try) 2>&5
3623   ac_status=$?
3624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3625   (exit $ac_status); }; }; then
3626   ac_cv_prog_cc_g=yes
3627 else
3628   echo "$as_me: failed program was:" >&5
3629 sed 's/^/| /' conftest.$ac_ext >&5
3630
3631 ac_cv_prog_cc_g=no
3632 fi
3633 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3634 fi
3635 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3636 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3637 if test "$ac_test_CFLAGS" = set; then
3638   CFLAGS=$ac_save_CFLAGS
3639 elif test $ac_cv_prog_cc_g = yes; then
3640   if test "$GCC" = yes; then
3641     CFLAGS="-g -O2"
3642   else
3643     CFLAGS="-g"
3644   fi
3645 else
3646   if test "$GCC" = yes; then
3647     CFLAGS="-O2"
3648   else
3649     CFLAGS=
3650   fi
3651 fi
3652 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3653 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3654 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3655   echo $ECHO_N "(cached) $ECHO_C" >&6
3656 else
3657   ac_cv_prog_cc_stdc=no
3658 ac_save_CC=$CC
3659 cat >conftest.$ac_ext <<_ACEOF
3660 /* confdefs.h.  */
3661 _ACEOF
3662 cat confdefs.h >>conftest.$ac_ext
3663 cat >>conftest.$ac_ext <<_ACEOF
3664 /* end confdefs.h.  */
3665 #include <stdarg.h>
3666 #include <stdio.h>
3667 #include <sys/types.h>
3668 #include <sys/stat.h>
3669 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3670 struct buf { int x; };
3671 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3672 static char *e (p, i)
3673      char **p;
3674      int i;
3675 {
3676   return p[i];
3677 }
3678 static char *f (char * (*g) (char **, int), char **p, ...)
3679 {
3680   char *s;
3681   va_list v;
3682   va_start (v,p);
3683   s = g (p, va_arg (v,int));
3684   va_end (v);
3685   return s;
3686 }
3687
3688 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3689    function prototypes and stuff, but not '\xHH' hex character constants.
3690    These don't provoke an error unfortunately, instead are silently treated
3691    as 'x'.  The following induces an error, until -std1 is added to get
3692    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3693    array size at least.  It's necessary to write '\x00'==0 to get something
3694    that's true only with -std1.  */
3695 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3696
3697 int test (int i, double x);
3698 struct s1 {int (*f) (int a);};
3699 struct s2 {int (*f) (double a);};
3700 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3701 int argc;
3702 char **argv;
3703 int
3704 main ()
3705 {
3706 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3707   ;
3708   return 0;
3709 }
3710 _ACEOF
3711 # Don't try gcc -ansi; that turns off useful extensions and
3712 # breaks some systems' header files.
3713 # AIX                   -qlanglvl=ansi
3714 # Ultrix and OSF/1      -std1
3715 # HP-UX 10.20 and later -Ae
3716 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3717 # SVR4                  -Xc -D__EXTENSIONS__
3718 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3719 do
3720   CC="$ac_save_CC $ac_arg"
3721   rm -f conftest.$ac_objext
3722 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3723   (eval $ac_compile) 2>conftest.er1
3724   ac_status=$?
3725   grep -v '^ *+' conftest.er1 >conftest.err
3726   rm -f conftest.er1
3727   cat conftest.err >&5
3728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3729   (exit $ac_status); } &&
3730          { ac_try='test -z "$ac_c_werror_flag"
3731                          || test ! -s conftest.err'
3732   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3733   (eval $ac_try) 2>&5
3734   ac_status=$?
3735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3736   (exit $ac_status); }; } &&
3737          { ac_try='test -s conftest.$ac_objext'
3738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3739   (eval $ac_try) 2>&5
3740   ac_status=$?
3741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3742   (exit $ac_status); }; }; then
3743   ac_cv_prog_cc_stdc=$ac_arg
3744 break
3745 else
3746   echo "$as_me: failed program was:" >&5
3747 sed 's/^/| /' conftest.$ac_ext >&5
3748
3749 fi
3750 rm -f conftest.err conftest.$ac_objext
3751 done
3752 rm -f conftest.$ac_ext conftest.$ac_objext
3753 CC=$ac_save_CC
3754
3755 fi
3756
3757 case "x$ac_cv_prog_cc_stdc" in
3758   x|xno)
3759     echo "$as_me:$LINENO: result: none needed" >&5
3760 echo "${ECHO_T}none needed" >&6 ;;
3761   *)
3762     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3763 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3764     CC="$CC $ac_cv_prog_cc_stdc" ;;
3765 esac
3766
3767 # Some people use a C++ compiler to compile C.  Since we use `exit',
3768 # in C++ we need to declare it.  In case someone uses the same compiler
3769 # for both compiling C and C++ we need to have the C++ compiler decide
3770 # the declaration of exit, since it's the most demanding environment.
3771 cat >conftest.$ac_ext <<_ACEOF
3772 #ifndef __cplusplus
3773   choke me
3774 #endif
3775 _ACEOF
3776 rm -f conftest.$ac_objext
3777 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3778   (eval $ac_compile) 2>conftest.er1
3779   ac_status=$?
3780   grep -v '^ *+' conftest.er1 >conftest.err
3781   rm -f conftest.er1
3782   cat conftest.err >&5
3783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3784   (exit $ac_status); } &&
3785          { ac_try='test -z "$ac_c_werror_flag"
3786                          || test ! -s conftest.err'
3787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3788   (eval $ac_try) 2>&5
3789   ac_status=$?
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); }; } &&
3792          { ac_try='test -s conftest.$ac_objext'
3793   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3794   (eval $ac_try) 2>&5
3795   ac_status=$?
3796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3797   (exit $ac_status); }; }; then
3798   for ac_declaration in \
3799    '' \
3800    'extern "C" void std::exit (int) throw (); using std::exit;' \
3801    'extern "C" void std::exit (int); using std::exit;' \
3802    'extern "C" void exit (int) throw ();' \
3803    'extern "C" void exit (int);' \
3804    'void exit (int);'
3805 do
3806   cat >conftest.$ac_ext <<_ACEOF
3807 /* confdefs.h.  */
3808 _ACEOF
3809 cat confdefs.h >>conftest.$ac_ext
3810 cat >>conftest.$ac_ext <<_ACEOF
3811 /* end confdefs.h.  */
3812 $ac_declaration
3813 #include <stdlib.h>
3814 int
3815 main ()
3816 {
3817 exit (42);
3818   ;
3819   return 0;
3820 }
3821 _ACEOF
3822 rm -f conftest.$ac_objext
3823 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3824   (eval $ac_compile) 2>conftest.er1
3825   ac_status=$?
3826   grep -v '^ *+' conftest.er1 >conftest.err
3827   rm -f conftest.er1
3828   cat conftest.err >&5
3829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3830   (exit $ac_status); } &&
3831          { ac_try='test -z "$ac_c_werror_flag"
3832                          || test ! -s conftest.err'
3833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3834   (eval $ac_try) 2>&5
3835   ac_status=$?
3836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3837   (exit $ac_status); }; } &&
3838          { ac_try='test -s conftest.$ac_objext'
3839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3840   (eval $ac_try) 2>&5
3841   ac_status=$?
3842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3843   (exit $ac_status); }; }; then
3844   :
3845 else
3846   echo "$as_me: failed program was:" >&5
3847 sed 's/^/| /' conftest.$ac_ext >&5
3848
3849 continue
3850 fi
3851 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3852   cat >conftest.$ac_ext <<_ACEOF
3853 /* confdefs.h.  */
3854 _ACEOF
3855 cat confdefs.h >>conftest.$ac_ext
3856 cat >>conftest.$ac_ext <<_ACEOF
3857 /* end confdefs.h.  */
3858 $ac_declaration
3859 int
3860 main ()
3861 {
3862 exit (42);
3863   ;
3864   return 0;
3865 }
3866 _ACEOF
3867 rm -f conftest.$ac_objext
3868 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3869   (eval $ac_compile) 2>conftest.er1
3870   ac_status=$?
3871   grep -v '^ *+' conftest.er1 >conftest.err
3872   rm -f conftest.er1
3873   cat conftest.err >&5
3874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3875   (exit $ac_status); } &&
3876          { ac_try='test -z "$ac_c_werror_flag"
3877                          || test ! -s conftest.err'
3878   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3879   (eval $ac_try) 2>&5
3880   ac_status=$?
3881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3882   (exit $ac_status); }; } &&
3883          { ac_try='test -s conftest.$ac_objext'
3884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3885   (eval $ac_try) 2>&5
3886   ac_status=$?
3887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3888   (exit $ac_status); }; }; then
3889   break
3890 else
3891   echo "$as_me: failed program was:" >&5
3892 sed 's/^/| /' conftest.$ac_ext >&5
3893
3894 fi
3895 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3896 done
3897 rm -f conftest*
3898 if test -n "$ac_declaration"; then
3899   echo '#ifdef __cplusplus' >>confdefs.h
3900   echo $ac_declaration      >>confdefs.h
3901   echo '#endif'             >>confdefs.h
3902 fi
3903
3904 else
3905   echo "$as_me: failed program was:" >&5
3906 sed 's/^/| /' conftest.$ac_ext >&5
3907
3908 fi
3909 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3910 ac_ext=c
3911 ac_cpp='$CPP $CPPFLAGS'
3912 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3913 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3914 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3915
3916 ac_ext=cc
3917 ac_cpp='$CXXCPP $CPPFLAGS'
3918 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3919 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3920 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3921 if test -n "$ac_tool_prefix"; then
3922   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3923   do
3924     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3925 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3926 echo "$as_me:$LINENO: checking for $ac_word" >&5
3927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3928 if test "${ac_cv_prog_CXX+set}" = set; then
3929   echo $ECHO_N "(cached) $ECHO_C" >&6
3930 else
3931   if test -n "$CXX"; then
3932   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3933 else
3934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3935 for as_dir in $PATH
3936 do
3937   IFS=$as_save_IFS
3938   test -z "$as_dir" && as_dir=.
3939   for ac_exec_ext in '' $ac_executable_extensions; do
3940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3941     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3943     break 2
3944   fi
3945 done
3946 done
3947
3948 fi
3949 fi
3950 CXX=$ac_cv_prog_CXX
3951 if test -n "$CXX"; then
3952   echo "$as_me:$LINENO: result: $CXX" >&5
3953 echo "${ECHO_T}$CXX" >&6
3954 else
3955   echo "$as_me:$LINENO: result: no" >&5
3956 echo "${ECHO_T}no" >&6
3957 fi
3958
3959     test -n "$CXX" && break
3960   done
3961 fi
3962 if test -z "$CXX"; then
3963   ac_ct_CXX=$CXX
3964   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3965 do
3966   # Extract the first word of "$ac_prog", so it can be a program name with args.
3967 set dummy $ac_prog; ac_word=$2
3968 echo "$as_me:$LINENO: checking for $ac_word" >&5
3969 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3970 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3971   echo $ECHO_N "(cached) $ECHO_C" >&6
3972 else
3973   if test -n "$ac_ct_CXX"; then
3974   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3975 else
3976 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3977 for as_dir in $PATH
3978 do
3979   IFS=$as_save_IFS
3980   test -z "$as_dir" && as_dir=.
3981   for ac_exec_ext in '' $ac_executable_extensions; do
3982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3983     ac_cv_prog_ac_ct_CXX="$ac_prog"
3984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3985     break 2
3986   fi
3987 done
3988 done
3989
3990 fi
3991 fi
3992 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3993 if test -n "$ac_ct_CXX"; then
3994   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3995 echo "${ECHO_T}$ac_ct_CXX" >&6
3996 else
3997   echo "$as_me:$LINENO: result: no" >&5
3998 echo "${ECHO_T}no" >&6
3999 fi
4000
4001   test -n "$ac_ct_CXX" && break
4002 done
4003 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
4004
4005   CXX=$ac_ct_CXX
4006 fi
4007
4008
4009 # Provide some information about the compiler.
4010 echo "$as_me:$LINENO:" \
4011      "checking for C++ compiler version" >&5
4012 ac_compiler=`set X $ac_compile; echo $2`
4013 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4014   (eval $ac_compiler --version </dev/null >&5) 2>&5
4015   ac_status=$?
4016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4017   (exit $ac_status); }
4018 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4019   (eval $ac_compiler -v </dev/null >&5) 2>&5
4020   ac_status=$?
4021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4022   (exit $ac_status); }
4023 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4024   (eval $ac_compiler -V </dev/null >&5) 2>&5
4025   ac_status=$?
4026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4027   (exit $ac_status); }
4028
4029 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4030 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4031 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4032   echo $ECHO_N "(cached) $ECHO_C" >&6
4033 else
4034   cat >conftest.$ac_ext <<_ACEOF
4035 /* confdefs.h.  */
4036 _ACEOF
4037 cat confdefs.h >>conftest.$ac_ext
4038 cat >>conftest.$ac_ext <<_ACEOF
4039 /* end confdefs.h.  */
4040
4041 int
4042 main ()
4043 {
4044 #ifndef __GNUC__
4045        choke me
4046 #endif
4047
4048   ;
4049   return 0;
4050 }
4051 _ACEOF
4052 rm -f conftest.$ac_objext
4053 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4054   (eval $ac_compile) 2>conftest.er1
4055   ac_status=$?
4056   grep -v '^ *+' conftest.er1 >conftest.err
4057   rm -f conftest.er1
4058   cat conftest.err >&5
4059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4060   (exit $ac_status); } &&
4061          { ac_try='test -z "$ac_cxx_werror_flag"
4062                          || test ! -s conftest.err'
4063   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4064   (eval $ac_try) 2>&5
4065   ac_status=$?
4066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4067   (exit $ac_status); }; } &&
4068          { ac_try='test -s conftest.$ac_objext'
4069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4070   (eval $ac_try) 2>&5
4071   ac_status=$?
4072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4073   (exit $ac_status); }; }; then
4074   ac_compiler_gnu=yes
4075 else
4076   echo "$as_me: failed program was:" >&5
4077 sed 's/^/| /' conftest.$ac_ext >&5
4078
4079 ac_compiler_gnu=no
4080 fi
4081 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4082 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4083
4084 fi
4085 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4086 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4087 GXX=`test $ac_compiler_gnu = yes && echo yes`
4088 ac_test_CXXFLAGS=${CXXFLAGS+set}
4089 ac_save_CXXFLAGS=$CXXFLAGS
4090 CXXFLAGS="-g"
4091 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4092 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4093 if test "${ac_cv_prog_cxx_g+set}" = set; then
4094   echo $ECHO_N "(cached) $ECHO_C" >&6
4095 else
4096   cat >conftest.$ac_ext <<_ACEOF
4097 /* confdefs.h.  */
4098 _ACEOF
4099 cat confdefs.h >>conftest.$ac_ext
4100 cat >>conftest.$ac_ext <<_ACEOF
4101 /* end confdefs.h.  */
4102
4103 int
4104 main ()
4105 {
4106
4107   ;
4108   return 0;
4109 }
4110 _ACEOF
4111 rm -f conftest.$ac_objext
4112 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4113   (eval $ac_compile) 2>conftest.er1
4114   ac_status=$?
4115   grep -v '^ *+' conftest.er1 >conftest.err
4116   rm -f conftest.er1
4117   cat conftest.err >&5
4118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4119   (exit $ac_status); } &&
4120          { ac_try='test -z "$ac_cxx_werror_flag"
4121                          || test ! -s conftest.err'
4122   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4123   (eval $ac_try) 2>&5
4124   ac_status=$?
4125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4126   (exit $ac_status); }; } &&
4127          { ac_try='test -s conftest.$ac_objext'
4128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4129   (eval $ac_try) 2>&5
4130   ac_status=$?
4131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4132   (exit $ac_status); }; }; then
4133   ac_cv_prog_cxx_g=yes
4134 else
4135   echo "$as_me: failed program was:" >&5
4136 sed 's/^/| /' conftest.$ac_ext >&5
4137
4138 ac_cv_prog_cxx_g=no
4139 fi
4140 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4141 fi
4142 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4143 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4144 if test "$ac_test_CXXFLAGS" = set; then
4145   CXXFLAGS=$ac_save_CXXFLAGS
4146 elif test $ac_cv_prog_cxx_g = yes; then
4147   if test "$GXX" = yes; then
4148     CXXFLAGS="-g -O2"
4149   else
4150     CXXFLAGS="-g"
4151   fi
4152 else
4153   if test "$GXX" = yes; then
4154     CXXFLAGS="-O2"
4155   else
4156     CXXFLAGS=
4157   fi
4158 fi
4159 for ac_declaration in \
4160    '' \
4161    'extern "C" void std::exit (int) throw (); using std::exit;' \
4162    'extern "C" void std::exit (int); using std::exit;' \
4163    'extern "C" void exit (int) throw ();' \
4164    'extern "C" void exit (int);' \
4165    'void exit (int);'
4166 do
4167   cat >conftest.$ac_ext <<_ACEOF
4168 /* confdefs.h.  */
4169 _ACEOF
4170 cat confdefs.h >>conftest.$ac_ext
4171 cat >>conftest.$ac_ext <<_ACEOF
4172 /* end confdefs.h.  */
4173 $ac_declaration
4174 #include <stdlib.h>
4175 int
4176 main ()
4177 {
4178 exit (42);
4179   ;
4180   return 0;
4181 }
4182 _ACEOF
4183 rm -f conftest.$ac_objext
4184 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4185   (eval $ac_compile) 2>conftest.er1
4186   ac_status=$?
4187   grep -v '^ *+' conftest.er1 >conftest.err
4188   rm -f conftest.er1
4189   cat conftest.err >&5
4190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4191   (exit $ac_status); } &&
4192          { ac_try='test -z "$ac_cxx_werror_flag"
4193                          || test ! -s conftest.err'
4194   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4195   (eval $ac_try) 2>&5
4196   ac_status=$?
4197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4198   (exit $ac_status); }; } &&
4199          { ac_try='test -s conftest.$ac_objext'
4200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4201   (eval $ac_try) 2>&5
4202   ac_status=$?
4203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4204   (exit $ac_status); }; }; then
4205   :
4206 else
4207   echo "$as_me: failed program was:" >&5
4208 sed 's/^/| /' conftest.$ac_ext >&5
4209
4210 continue
4211 fi
4212 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4213   cat >conftest.$ac_ext <<_ACEOF
4214 /* confdefs.h.  */
4215 _ACEOF
4216 cat confdefs.h >>conftest.$ac_ext
4217 cat >>conftest.$ac_ext <<_ACEOF
4218 /* end confdefs.h.  */
4219 $ac_declaration
4220 int
4221 main ()
4222 {
4223 exit (42);
4224   ;
4225   return 0;
4226 }
4227 _ACEOF
4228 rm -f conftest.$ac_objext
4229 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4230   (eval $ac_compile) 2>conftest.er1
4231   ac_status=$?
4232   grep -v '^ *+' conftest.er1 >conftest.err
4233   rm -f conftest.er1
4234   cat conftest.err >&5
4235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4236   (exit $ac_status); } &&
4237          { ac_try='test -z "$ac_cxx_werror_flag"
4238                          || test ! -s conftest.err'
4239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4240   (eval $ac_try) 2>&5
4241   ac_status=$?
4242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4243   (exit $ac_status); }; } &&
4244          { ac_try='test -s conftest.$ac_objext'
4245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4246   (eval $ac_try) 2>&5
4247   ac_status=$?
4248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4249   (exit $ac_status); }; }; then
4250   break
4251 else
4252   echo "$as_me: failed program was:" >&5
4253 sed 's/^/| /' conftest.$ac_ext >&5
4254
4255 fi
4256 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4257 done
4258 rm -f conftest*
4259 if test -n "$ac_declaration"; then
4260   echo '#ifdef __cplusplus' >>confdefs.h
4261   echo $ac_declaration      >>confdefs.h
4262   echo '#endif'             >>confdefs.h
4263 fi
4264
4265 ac_ext=c
4266 ac_cpp='$CPP $CPPFLAGS'
4267 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4268 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4269 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4270
4271
4272 # We must set the default linker to the linker used by gcc for the correct
4273 # operation of libtool.  If LD is not defined and we are using gcc, try to
4274 # set the LD default to the ld used by gcc.
4275 if test -z "$LD"; then
4276   if test "$GCC" = yes; then
4277     case $build in
4278     *-*-mingw*)
4279       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4280     *)
4281       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4282     esac
4283     case $gcc_prog_ld in
4284     # Accept absolute paths.
4285     [\\/]* | [A-Za-z]:[\\/]*)
4286       LD="$gcc_prog_ld" ;;
4287     esac
4288   fi
4289 fi
4290
4291
4292
4293
4294 if test -n "$ac_tool_prefix"; then
4295   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4296 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4297 echo "$as_me:$LINENO: checking for $ac_word" >&5
4298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4299 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4300   echo $ECHO_N "(cached) $ECHO_C" >&6
4301 else
4302   if test -n "$GNATBIND"; then
4303   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4304 else
4305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4306 for as_dir in $PATH
4307 do
4308   IFS=$as_save_IFS
4309   test -z "$as_dir" && as_dir=.
4310   for ac_exec_ext in '' $ac_executable_extensions; do
4311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4312     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4314     break 2
4315   fi
4316 done
4317 done
4318
4319 fi
4320 fi
4321 GNATBIND=$ac_cv_prog_GNATBIND
4322 if test -n "$GNATBIND"; then
4323   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4324 echo "${ECHO_T}$GNATBIND" >&6
4325 else
4326   echo "$as_me:$LINENO: result: no" >&5
4327 echo "${ECHO_T}no" >&6
4328 fi
4329
4330 fi
4331 if test -z "$ac_cv_prog_GNATBIND"; then
4332   ac_ct_GNATBIND=$GNATBIND
4333   # Extract the first word of "gnatbind", so it can be a program name with args.
4334 set dummy gnatbind; ac_word=$2
4335 echo "$as_me:$LINENO: checking for $ac_word" >&5
4336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4337 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4338   echo $ECHO_N "(cached) $ECHO_C" >&6
4339 else
4340   if test -n "$ac_ct_GNATBIND"; then
4341   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4342 else
4343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4344 for as_dir in $PATH
4345 do
4346   IFS=$as_save_IFS
4347   test -z "$as_dir" && as_dir=.
4348   for ac_exec_ext in '' $ac_executable_extensions; do
4349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4350     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4352     break 2
4353   fi
4354 done
4355 done
4356
4357   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4358 fi
4359 fi
4360 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4361 if test -n "$ac_ct_GNATBIND"; then
4362   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4363 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4364 else
4365   echo "$as_me:$LINENO: result: no" >&5
4366 echo "${ECHO_T}no" >&6
4367 fi
4368
4369   GNATBIND=$ac_ct_GNATBIND
4370 else
4371   GNATBIND="$ac_cv_prog_GNATBIND"
4372 fi
4373
4374 if test -n "$ac_tool_prefix"; then
4375   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4376 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4377 echo "$as_me:$LINENO: checking for $ac_word" >&5
4378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4379 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4380   echo $ECHO_N "(cached) $ECHO_C" >&6
4381 else
4382   if test -n "$GNATMAKE"; then
4383   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4384 else
4385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4386 for as_dir in $PATH
4387 do
4388   IFS=$as_save_IFS
4389   test -z "$as_dir" && as_dir=.
4390   for ac_exec_ext in '' $ac_executable_extensions; do
4391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4392     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4394     break 2
4395   fi
4396 done
4397 done
4398
4399 fi
4400 fi
4401 GNATMAKE=$ac_cv_prog_GNATMAKE
4402 if test -n "$GNATMAKE"; then
4403   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4404 echo "${ECHO_T}$GNATMAKE" >&6
4405 else
4406   echo "$as_me:$LINENO: result: no" >&5
4407 echo "${ECHO_T}no" >&6
4408 fi
4409
4410 fi
4411 if test -z "$ac_cv_prog_GNATMAKE"; then
4412   ac_ct_GNATMAKE=$GNATMAKE
4413   # Extract the first word of "gnatmake", so it can be a program name with args.
4414 set dummy gnatmake; ac_word=$2
4415 echo "$as_me:$LINENO: checking for $ac_word" >&5
4416 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4417 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4418   echo $ECHO_N "(cached) $ECHO_C" >&6
4419 else
4420   if test -n "$ac_ct_GNATMAKE"; then
4421   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4422 else
4423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4424 for as_dir in $PATH
4425 do
4426   IFS=$as_save_IFS
4427   test -z "$as_dir" && as_dir=.
4428   for ac_exec_ext in '' $ac_executable_extensions; do
4429   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4430     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4431     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4432     break 2
4433   fi
4434 done
4435 done
4436
4437   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4438 fi
4439 fi
4440 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4441 if test -n "$ac_ct_GNATMAKE"; then
4442   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4443 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4444 else
4445   echo "$as_me:$LINENO: result: no" >&5
4446 echo "${ECHO_T}no" >&6
4447 fi
4448
4449   GNATMAKE=$ac_ct_GNATMAKE
4450 else
4451   GNATMAKE="$ac_cv_prog_GNATMAKE"
4452 fi
4453
4454 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4455 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4456 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4457   echo $ECHO_N "(cached) $ECHO_C" >&6
4458 else
4459   cat >conftest.adb <<EOF
4460 procedure conftest is begin null; end conftest;
4461 EOF
4462 acx_cv_cc_gcc_supports_ada=no
4463 # There is a bug in old released versions of GCC which causes the
4464 # driver to exit successfully when the appropriate language module
4465 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4466 # Therefore we must check for the error message as well as an
4467 # unsuccessful exit.
4468 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4469 # given a .adb file, but produce no object file.  So we must check
4470 # if an object file was really produced to guard against this.
4471 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4472 if test x"$errors" = x && test -f conftest.$ac_objext; then
4473   acx_cv_cc_gcc_supports_ada=yes
4474 fi
4475 rm -f conftest.*
4476 fi
4477 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4478 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4479
4480 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4481   have_gnat=yes
4482 else
4483   have_gnat=no
4484 fi
4485
4486 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4487 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4488 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4489   echo $ECHO_N "(cached) $ECHO_C" >&6
4490 else
4491    echo abfoo >t1
4492   echo cdfoo >t2
4493   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4494   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4495     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4496       :
4497     else
4498       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4499     fi
4500   fi
4501   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4502     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4503       :
4504     else
4505       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4506     fi
4507   fi
4508   rm t1 t2
4509
4510 fi
4511 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4512 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4513 do_compare="$gcc_cv_prog_cmp_skip"
4514
4515
4516
4517 # See if we are building gcc with C++.
4518 # Check whether --enable-build-with-cxx or --disable-build-with-cxx was given.
4519 if test "${enable_build_with_cxx+set}" = set; then
4520   enableval="$enable_build_with_cxx"
4521   ENABLE_BUILD_WITH_CXX=$enableval
4522 else
4523   ENABLE_BUILD_WITH_CXX=no
4524 fi;
4525
4526 # Check for GMP, MPFR and MPC
4527 gmplibs="-lmpfr -lgmp"
4528 gmpinc=
4529 have_gmp=no
4530 mpclibs=-lmpc
4531 mpcinc=
4532 have_mpc=no
4533
4534 # Specify a location for mpc
4535 # check for this first so it ends up on the link line before mpfr.
4536
4537 # Check whether --with-mpc or --without-mpc was given.
4538 if test "${with_mpc+set}" = set; then
4539   withval="$with_mpc"
4540
4541 fi;
4542
4543 # Check whether --with-mpc_include or --without-mpc_include was given.
4544 if test "${with_mpc_include+set}" = set; then
4545   withval="$with_mpc_include"
4546
4547 fi;
4548
4549 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4550 if test "${with_mpc_lib+set}" = set; then
4551   withval="$with_mpc_lib"
4552
4553 fi;
4554
4555 if test "x$with_mpc" != x; then
4556   mpclibs="-L$with_mpc/lib -lmpc"
4557   mpcinc="-I$with_mpc/include $mpcinc"
4558 fi
4559 if test "x$with_mpc_include" != x; then
4560   mpcinc="-I$with_mpc_include $mpcinc"
4561 fi
4562 if test "x$with_mpc_lib" != x; then
4563   mpclibs="-L$with_mpc_lib -lmpc"
4564 fi
4565 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4566   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4567   mpcinc='-I$$s/mpc/src '"$mpcinc"
4568   # Do not test the mpc version.  Assume that it is sufficient, since
4569   # it is in the source tree, and the library has not been built yet
4570   # but it would be included on the link line in the version check below
4571   # hence making the test fail.
4572   have_mpc=yes
4573 fi
4574
4575 # Specify a location for mpfr
4576 # check for this first so it ends up on the link line before gmp.
4577
4578 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4579 if test "${with_mpfr_dir+set}" = set; then
4580   withval="$with_mpfr_dir"
4581   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4582 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4583 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4584 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4585    { (exit 1); exit 1; }; }
4586 fi;
4587
4588
4589 # Check whether --with-mpfr or --without-mpfr was given.
4590 if test "${with_mpfr+set}" = set; then
4591   withval="$with_mpfr"
4592
4593 fi;
4594
4595 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4596 if test "${with_mpfr_include+set}" = set; then
4597   withval="$with_mpfr_include"
4598
4599 fi;
4600
4601 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4602 if test "${with_mpfr_lib+set}" = set; then
4603   withval="$with_mpfr_lib"
4604
4605 fi;
4606
4607 if test "x$with_mpfr" != x; then
4608   gmplibs="-L$with_mpfr/lib $gmplibs"
4609   gmpinc="-I$with_mpfr/include"
4610 fi
4611 if test "x$with_mpfr_include" != x; then
4612   gmpinc="-I$with_mpfr_include"
4613 fi
4614 if test "x$with_mpfr_lib" != x; then
4615   gmplibs="-L$with_mpfr_lib $gmplibs"
4616 fi
4617 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4618   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4619   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4620   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4621   # Do not test the mpfr version.  Assume that it is sufficient, since
4622   # it is in the source tree, and the library has not been built yet
4623   # but it would be included on the link line in the version check below
4624   # hence making the test fail.
4625   have_gmp=yes
4626 fi
4627
4628 # Specify a location for gmp
4629
4630 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4631 if test "${with_gmp_dir+set}" = set; then
4632   withval="$with_gmp_dir"
4633   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4634 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4635 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4636 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4637    { (exit 1); exit 1; }; }
4638 fi;
4639
4640
4641 # Check whether --with-gmp or --without-gmp was given.
4642 if test "${with_gmp+set}" = set; then
4643   withval="$with_gmp"
4644
4645 fi;
4646
4647 # Check whether --with-gmp_include or --without-gmp_include was given.
4648 if test "${with_gmp_include+set}" = set; then
4649   withval="$with_gmp_include"
4650
4651 fi;
4652
4653 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4654 if test "${with_gmp_lib+set}" = set; then
4655   withval="$with_gmp_lib"
4656
4657 fi;
4658
4659
4660 if test "x$with_gmp" != x; then
4661   gmplibs="-L$with_gmp/lib $gmplibs"
4662   gmpinc="-I$with_gmp/include $gmpinc"
4663 fi
4664 if test "x$with_gmp_include" != x; then
4665   gmpinc="-I$with_gmp_include $gmpinc"
4666 fi
4667 if test "x$with_gmp_lib" != x; then
4668   gmplibs="-L$with_gmp_lib $gmplibs"
4669 fi
4670 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4671   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4672   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4673   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4674   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4675   # Do not test the gmp version.  Assume that it is sufficient, since
4676   # it is in the source tree, and the library has not been built yet
4677   # but it would be included on the link line in the version check below
4678   # hence making the test fail.
4679   have_gmp=yes
4680 fi
4681
4682 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4683   have_gmp=yes
4684   saved_CFLAGS="$CFLAGS"
4685   CFLAGS="$CFLAGS $gmpinc"
4686   # Check GMP actually works
4687   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4688 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4689
4690 cat >conftest.$ac_ext <<_ACEOF
4691 /* confdefs.h.  */
4692 _ACEOF
4693 cat confdefs.h >>conftest.$ac_ext
4694 cat >>conftest.$ac_ext <<_ACEOF
4695 /* end confdefs.h.  */
4696 #include "gmp.h"
4697 int
4698 main ()
4699 {
4700
4701   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4702   choke me
4703   #endif
4704
4705   ;
4706   return 0;
4707 }
4708 _ACEOF
4709 rm -f conftest.$ac_objext
4710 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4711   (eval $ac_compile) 2>conftest.er1
4712   ac_status=$?
4713   grep -v '^ *+' conftest.er1 >conftest.err
4714   rm -f conftest.er1
4715   cat conftest.err >&5
4716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4717   (exit $ac_status); } &&
4718          { ac_try='test -z "$ac_c_werror_flag"
4719                          || test ! -s conftest.err'
4720   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4721   (eval $ac_try) 2>&5
4722   ac_status=$?
4723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4724   (exit $ac_status); }; } &&
4725          { ac_try='test -s conftest.$ac_objext'
4726   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4727   (eval $ac_try) 2>&5
4728   ac_status=$?
4729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4730   (exit $ac_status); }; }; then
4731   echo "$as_me:$LINENO: result: yes" >&5
4732 echo "${ECHO_T}yes" >&6
4733 else
4734   echo "$as_me: failed program was:" >&5
4735 sed 's/^/| /' conftest.$ac_ext >&5
4736
4737 echo "$as_me:$LINENO: result: no" >&5
4738 echo "${ECHO_T}no" >&6; have_gmp=no
4739 fi
4740 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4741
4742   # If we have GMP, check the MPFR version.
4743   if test x"$have_gmp" = xyes; then
4744         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4745 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4746     cat >conftest.$ac_ext <<_ACEOF
4747 /* confdefs.h.  */
4748 _ACEOF
4749 cat confdefs.h >>conftest.$ac_ext
4750 cat >>conftest.$ac_ext <<_ACEOF
4751 /* end confdefs.h.  */
4752 #include <gmp.h>
4753     #include <mpfr.h>
4754 int
4755 main ()
4756 {
4757
4758     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4759     choke me
4760     #endif
4761
4762   ;
4763   return 0;
4764 }
4765 _ACEOF
4766 rm -f conftest.$ac_objext
4767 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4768   (eval $ac_compile) 2>conftest.er1
4769   ac_status=$?
4770   grep -v '^ *+' conftest.er1 >conftest.err
4771   rm -f conftest.er1
4772   cat conftest.err >&5
4773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4774   (exit $ac_status); } &&
4775          { ac_try='test -z "$ac_c_werror_flag"
4776                          || test ! -s conftest.err'
4777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4778   (eval $ac_try) 2>&5
4779   ac_status=$?
4780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4781   (exit $ac_status); }; } &&
4782          { ac_try='test -s conftest.$ac_objext'
4783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4784   (eval $ac_try) 2>&5
4785   ac_status=$?
4786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4787   (exit $ac_status); }; }; then
4788   cat >conftest.$ac_ext <<_ACEOF
4789 /* confdefs.h.  */
4790 _ACEOF
4791 cat confdefs.h >>conftest.$ac_ext
4792 cat >>conftest.$ac_ext <<_ACEOF
4793 /* end confdefs.h.  */
4794 #include <gmp.h>
4795     #include <mpfr.h>
4796 int
4797 main ()
4798 {
4799
4800     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4801     choke me
4802     #endif
4803
4804   ;
4805   return 0;
4806 }
4807 _ACEOF
4808 rm -f conftest.$ac_objext
4809 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4810   (eval $ac_compile) 2>conftest.er1
4811   ac_status=$?
4812   grep -v '^ *+' conftest.er1 >conftest.err
4813   rm -f conftest.er1
4814   cat conftest.err >&5
4815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4816   (exit $ac_status); } &&
4817          { ac_try='test -z "$ac_c_werror_flag"
4818                          || test ! -s conftest.err'
4819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4820   (eval $ac_try) 2>&5
4821   ac_status=$?
4822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4823   (exit $ac_status); }; } &&
4824          { ac_try='test -s conftest.$ac_objext'
4825   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4826   (eval $ac_try) 2>&5
4827   ac_status=$?
4828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4829   (exit $ac_status); }; }; then
4830   echo "$as_me:$LINENO: result: yes" >&5
4831 echo "${ECHO_T}yes" >&6
4832 else
4833   echo "$as_me: failed program was:" >&5
4834 sed 's/^/| /' conftest.$ac_ext >&5
4835
4836 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4837 echo "${ECHO_T}buggy but acceptable" >&6
4838 fi
4839 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4840 else
4841   echo "$as_me: failed program was:" >&5
4842 sed 's/^/| /' conftest.$ac_ext >&5
4843
4844 echo "$as_me:$LINENO: result: no" >&5
4845 echo "${ECHO_T}no" >&6; have_gmp=no
4846 fi
4847 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4848   fi
4849
4850   # Check for the MPC header version.
4851   if test x"$have_mpc" != xyes ; then
4852     CFLAGS="$CFLAGS $mpcinc"
4853     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4854 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4855     cat >conftest.$ac_ext <<_ACEOF
4856 /* confdefs.h.  */
4857 _ACEOF
4858 cat confdefs.h >>conftest.$ac_ext
4859 cat >>conftest.$ac_ext <<_ACEOF
4860 /* end confdefs.h.  */
4861 #include <mpc.h>
4862 int
4863 main ()
4864 {
4865
4866     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4867     choke me
4868     #endif
4869
4870   ;
4871   return 0;
4872 }
4873 _ACEOF
4874 rm -f conftest.$ac_objext
4875 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4876   (eval $ac_compile) 2>conftest.er1
4877   ac_status=$?
4878   grep -v '^ *+' conftest.er1 >conftest.err
4879   rm -f conftest.er1
4880   cat conftest.err >&5
4881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4882   (exit $ac_status); } &&
4883          { ac_try='test -z "$ac_c_werror_flag"
4884                          || test ! -s conftest.err'
4885   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4886   (eval $ac_try) 2>&5
4887   ac_status=$?
4888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4889   (exit $ac_status); }; } &&
4890          { ac_try='test -s conftest.$ac_objext'
4891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4892   (eval $ac_try) 2>&5
4893   ac_status=$?
4894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4895   (exit $ac_status); }; }; then
4896   echo "$as_me:$LINENO: result: yes" >&5
4897 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4898 else
4899   echo "$as_me: failed program was:" >&5
4900 sed 's/^/| /' conftest.$ac_ext >&5
4901
4902 echo "$as_me:$LINENO: result: no" >&5
4903 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4904 fi
4905 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4906   fi
4907
4908   # Now check the MPFR library.
4909   if test x"$have_gmp" = xyes; then
4910     saved_LIBS="$LIBS"
4911     LIBS="$LIBS $gmplibs"
4912     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4913 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4914     cat >conftest.$ac_ext <<_ACEOF
4915 /* confdefs.h.  */
4916 _ACEOF
4917 cat confdefs.h >>conftest.$ac_ext
4918 cat >>conftest.$ac_ext <<_ACEOF
4919 /* end confdefs.h.  */
4920 #include <gmp.h>
4921     #include <mpfr.h>
4922 int
4923 main ()
4924 {
4925
4926     mpfr_t n;
4927     mpfr_t x;
4928     int t;
4929     mpfr_init (n);
4930     mpfr_init (x);
4931     mpfr_atan2 (n, n, x, GMP_RNDN);
4932     mpfr_erfc (n, x, GMP_RNDN);
4933     mpfr_subnormalize (x, t, GMP_RNDN);
4934
4935   ;
4936   return 0;
4937 }
4938 _ACEOF
4939 rm -f conftest.$ac_objext conftest$ac_exeext
4940 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4941   (eval $ac_link) 2>conftest.er1
4942   ac_status=$?
4943   grep -v '^ *+' conftest.er1 >conftest.err
4944   rm -f conftest.er1
4945   cat conftest.err >&5
4946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4947   (exit $ac_status); } &&
4948          { ac_try='test -z "$ac_c_werror_flag"
4949                          || test ! -s conftest.err'
4950   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4951   (eval $ac_try) 2>&5
4952   ac_status=$?
4953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4954   (exit $ac_status); }; } &&
4955          { ac_try='test -s conftest$ac_exeext'
4956   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4957   (eval $ac_try) 2>&5
4958   ac_status=$?
4959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4960   (exit $ac_status); }; }; then
4961   echo "$as_me:$LINENO: result: yes" >&5
4962 echo "${ECHO_T}yes" >&6
4963 else
4964   echo "$as_me: failed program was:" >&5
4965 sed 's/^/| /' conftest.$ac_ext >&5
4966
4967 echo "$as_me:$LINENO: result: no" >&5
4968 echo "${ECHO_T}no" >&6; have_gmp=no
4969 fi
4970 rm -f conftest.err conftest.$ac_objext \
4971       conftest$ac_exeext conftest.$ac_ext
4972     LIBS="$saved_LIBS"
4973   fi
4974
4975   if test x"$have_mpc" = xmaybe; then
4976     saved_LIBS="$LIBS"
4977     LIBS="$LIBS $mpclibs $gmplibs"
4978     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4979 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4980     cat >conftest.$ac_ext <<_ACEOF
4981 /* confdefs.h.  */
4982 _ACEOF
4983 cat confdefs.h >>conftest.$ac_ext
4984 cat >>conftest.$ac_ext <<_ACEOF
4985 /* end confdefs.h.  */
4986 #include <mpc.h>
4987 int
4988 main ()
4989 {
4990
4991     mpc_t n;
4992     mpc_init2 (n, 53);
4993     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
4994     mpc_sin (n, n, MPC_RNDNN);
4995     mpc_cos (n, n, MPC_RNDNN);
4996     mpc_tan (n, n, MPC_RNDNN);
4997     mpc_sinh (n, n, MPC_RNDNN);
4998     mpc_cosh (n, n, MPC_RNDNN);
4999     mpc_tanh (n, n, MPC_RNDNN);
5000     mpc_exp (n, n, MPC_RNDNN);
5001     mpc_log (n, n, MPC_RNDNN);
5002     mpc_sqrt (n, n, MPC_RNDNN);
5003     mpc_proj (n, n, MPC_RNDNN);
5004     mpc_neg (n, n, MPC_RNDNN);
5005     mpc_sqr (n, n, MPC_RNDNN);
5006     mpc_clear (n);
5007
5008   ;
5009   return 0;
5010 }
5011 _ACEOF
5012 rm -f conftest.$ac_objext conftest$ac_exeext
5013 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5014   (eval $ac_link) 2>conftest.er1
5015   ac_status=$?
5016   grep -v '^ *+' conftest.er1 >conftest.err
5017   rm -f conftest.er1
5018   cat conftest.err >&5
5019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5020   (exit $ac_status); } &&
5021          { ac_try='test -z "$ac_c_werror_flag"
5022                          || test ! -s conftest.err'
5023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5024   (eval $ac_try) 2>&5
5025   ac_status=$?
5026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5027   (exit $ac_status); }; } &&
5028          { ac_try='test -s conftest$ac_exeext'
5029   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5030   (eval $ac_try) 2>&5
5031   ac_status=$?
5032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5033   (exit $ac_status); }; }; then
5034   echo "$as_me:$LINENO: result: yes" >&5
5035 echo "${ECHO_T}yes" >&6; have_mpc=yes
5036 else
5037   echo "$as_me: failed program was:" >&5
5038 sed 's/^/| /' conftest.$ac_ext >&5
5039
5040 echo "$as_me:$LINENO: result: no" >&5
5041 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5042 fi
5043 rm -f conftest.err conftest.$ac_objext \
5044       conftest$ac_exeext conftest.$ac_ext
5045     LIBS="$saved_LIBS"
5046   fi
5047
5048   CFLAGS="$saved_CFLAGS"
5049
5050   if test x$have_gmp != xyes; then
5051     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5052 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5053 Copies of these libraries' source code can be found at their respective
5054 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5055 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5056 If you obtained GMP and/or MPFR from a vendor distribution package, make
5057 sure that you have installed both the libraries and the header files.
5058 They may be located in separate packages." >&5
5059 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5060 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5061 Copies of these libraries' source code can be found at their respective
5062 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5063 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5064 If you obtained GMP and/or MPFR from a vendor distribution package, make
5065 sure that you have installed both the libraries and the header files.
5066 They may be located in separate packages." >&2;}
5067    { (exit 1); exit 1; }; }
5068   fi
5069 fi
5070
5071 if test x$have_mpc != xyes ; then
5072   mpcinc=
5073   mpclibs=
5074 fi
5075
5076 gmpinc="$mpcinc $gmpinc"
5077 gmplibs="$mpclibs $gmplibs"
5078
5079 # Flags needed for both GMP, MPFR and/or MPC.
5080
5081
5082
5083
5084
5085
5086 # Allow host libstdc++ to be specified for static linking with PPL.
5087
5088 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5089 if test "${with_host_libstdcxx+set}" = set; then
5090   withval="$with_host_libstdcxx"
5091
5092 fi;
5093
5094 case $with_host_libstdcxx in
5095   no|yes)
5096     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5097 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5098    { (exit 1); exit 1; }; }
5099     ;;
5100 esac
5101
5102 # Linker flags to use for stage1 or when not boostrapping.
5103
5104 # Check whether --with-stage1-ldflags or --without-stage1-ldflags was given.
5105 if test "${with_stage1_ldflags+set}" = set; then
5106   withval="$with_stage1_ldflags"
5107   if test "$withval" = "no" -o "$withval" = "yes"; then
5108    stage1_ldflags=
5109  else
5110    stage1_ldflags=$withval
5111  fi
5112 else
5113   stage1_ldflags=
5114 fi;
5115
5116
5117 # Libraries to use for stage1 or when not bootstrapping.
5118
5119 # Check whether --with-stage1-libs or --without-stage1-libs was given.
5120 if test "${with_stage1_libs+set}" = set; then
5121   withval="$with_stage1_libs"
5122   if test "$withval" = "no" -o "$withval" = "yes"; then
5123    stage1_libs=
5124  else
5125    stage1_libs=$withval
5126  fi
5127 else
5128   stage1_libs=$with_host_libstdcxx
5129 fi;
5130
5131
5132 # Linker flags to use for stage2 and later builds.
5133
5134 # Check whether --with-boot-ldflags or --without-boot-ldflags was given.
5135 if test "${with_boot_ldflags+set}" = set; then
5136   withval="$with_boot_ldflags"
5137   if test "$withval" = "no" -o "$withval" = "yes"; then
5138    poststage1_ldflags=
5139  else
5140    poststage1_ldflags=$withval
5141  fi
5142 else
5143   if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5144    poststage1_ldflags=-static-libstdc++
5145  else
5146    poststage1_ldflags=
5147  fi
5148 fi;
5149
5150
5151 # Libraries to use for stage2 and later builds.  This defaults to the
5152 # argument passed to --with-host-libstdcxx.
5153
5154 # Check whether --with-boot-libs or --without-boot-libs was given.
5155 if test "${with_boot_libs+set}" = set; then
5156   withval="$with_boot_libs"
5157   poststage1_libs=$with_host_libstdcxx
5158 fi;
5159
5160
5161 # Check for PPL
5162 ppl_major_version=0
5163 ppl_minor_version=10
5164 ppllibs=" -lppl_c -lppl -lgmpxx"
5165 pplinc=
5166
5167
5168 # Check whether --with-ppl or --without-ppl was given.
5169 if test "${with_ppl+set}" = set; then
5170   withval="$with_ppl"
5171
5172 else
5173   with_ppl=no
5174 fi;
5175
5176 # Check whether --with-ppl_include or --without-ppl_include was given.
5177 if test "${with_ppl_include+set}" = set; then
5178   withval="$with_ppl_include"
5179
5180 fi;
5181
5182 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5183 if test "${with_ppl_lib+set}" = set; then
5184   withval="$with_ppl_lib"
5185
5186 fi;
5187
5188 case $with_ppl in
5189   no)
5190     ppllibs=
5191     ;;
5192   *)
5193     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
5194     pplinc="-I$with_ppl/include $pplinc"
5195     LIBS="$ppllibs $LIBS"
5196     ;;
5197 esac
5198 if test "x$with_ppl_include" != x; then
5199   pplinc="-I$with_ppl_include $pplinc"
5200 fi
5201 if test "x$with_ppl_lib" != x; then
5202   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
5203   LIBS="$ppllibs $LIBS"
5204 fi
5205 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5206   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
5207   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5208   LIBS="$ppllibs $LIBS"
5209 fi
5210
5211 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5212 if test "${enable_ppl_version_check+set}" = set; then
5213   enableval="$enable_ppl_version_check"
5214   ENABLE_PPL_CHECK=$enableval
5215 else
5216   ENABLE_PPL_CHECK=yes
5217 fi;
5218
5219 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5220   saved_CFLAGS="$CFLAGS"
5221   CFLAGS="$CFLAGS $pplinc $gmpinc"
5222   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5223 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5224   cat >conftest.$ac_ext <<_ACEOF
5225 /* confdefs.h.  */
5226 _ACEOF
5227 cat confdefs.h >>conftest.$ac_ext
5228 cat >>conftest.$ac_ext <<_ACEOF
5229 /* end confdefs.h.  */
5230 #include "ppl_c.h"
5231 int
5232 main ()
5233 {
5234
5235   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5236   choke me
5237   #endif
5238
5239   ;
5240   return 0;
5241 }
5242 _ACEOF
5243 rm -f conftest.$ac_objext
5244 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5245   (eval $ac_compile) 2>conftest.er1
5246   ac_status=$?
5247   grep -v '^ *+' conftest.er1 >conftest.err
5248   rm -f conftest.er1
5249   cat conftest.err >&5
5250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5251   (exit $ac_status); } &&
5252          { ac_try='test -z "$ac_c_werror_flag"
5253                          || test ! -s conftest.err'
5254   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5255   (eval $ac_try) 2>&5
5256   ac_status=$?
5257   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5258   (exit $ac_status); }; } &&
5259          { ac_try='test -s conftest.$ac_objext'
5260   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5261   (eval $ac_try) 2>&5
5262   ac_status=$?
5263   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5264   (exit $ac_status); }; }; then
5265   echo "$as_me:$LINENO: result: yes" >&5
5266 echo "${ECHO_T}yes" >&6
5267 else
5268   echo "$as_me: failed program was:" >&5
5269 sed 's/^/| /' conftest.$ac_ext >&5
5270
5271 echo "$as_me:$LINENO: result: no" >&5
5272 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5273 fi
5274 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5275   CFLAGS="$saved_CFLAGS"
5276 fi
5277
5278 # Flags needed for PPL
5279
5280
5281
5282
5283 # Check for CLOOG
5284 clooglibs=" -lcloog "
5285 clooginc=" -DCLOOG_PPL_BACKEND "
5286
5287
5288 # Check whether --with-cloog or --without-cloog was given.
5289 if test "${with_cloog+set}" = set; then
5290   withval="$with_cloog"
5291
5292 else
5293   with_cloog=no
5294 fi;
5295
5296 # Check whether --with-cloog_include or --without-cloog_include was given.
5297 if test "${with_cloog_include+set}" = set; then
5298   withval="$with_cloog_include"
5299
5300 fi;
5301
5302 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5303 if test "${with_cloog_lib+set}" = set; then
5304   withval="$with_cloog_lib"
5305
5306 fi;
5307
5308 case $with_cloog in
5309   no)
5310     clooglibs=
5311     clooginc=
5312     ;;
5313   *)
5314     clooglibs="-L$with_cloog/lib -lcloog"
5315     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5316     LIBS="$clooglibs $LIBS"
5317     ;;
5318 esac
5319 if test "x$with_cloog_include" != x; then
5320   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5321 fi
5322 if test "x$with_cloog_lib" != x; then
5323   clooglibs="-L$with_cloog_lib -lcloog"
5324   LIBS="$clooglibs $LIBS"
5325 fi
5326 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5327   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5328   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5329   LIBS="$clooglibs $LIBS"
5330 fi
5331
5332 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5333 if test "${enable_cloog_version_check+set}" = set; then
5334   enableval="$enable_cloog_version_check"
5335   ENABLE_CLOOG_CHECK=$enableval
5336 else
5337   ENABLE_CLOOG_CHECK=yes
5338 fi;
5339
5340 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5341   saved_CFLAGS="$CFLAGS"
5342   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5343   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5344 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5345   cat >conftest.$ac_ext <<_ACEOF
5346 /* confdefs.h.  */
5347 _ACEOF
5348 cat confdefs.h >>conftest.$ac_ext
5349 cat >>conftest.$ac_ext <<_ACEOF
5350 /* end confdefs.h.  */
5351 #include "cloog/cloog.h"
5352 int
5353 main ()
5354 {
5355
5356   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5357   choke me
5358   #endif
5359
5360   ;
5361   return 0;
5362 }
5363 _ACEOF
5364 rm -f conftest.$ac_objext
5365 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5366   (eval $ac_compile) 2>conftest.er1
5367   ac_status=$?
5368   grep -v '^ *+' conftest.er1 >conftest.err
5369   rm -f conftest.er1
5370   cat conftest.err >&5
5371   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5372   (exit $ac_status); } &&
5373          { ac_try='test -z "$ac_c_werror_flag"
5374                          || test ! -s conftest.err'
5375   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5376   (eval $ac_try) 2>&5
5377   ac_status=$?
5378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5379   (exit $ac_status); }; } &&
5380          { ac_try='test -s conftest.$ac_objext'
5381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5382   (eval $ac_try) 2>&5
5383   ac_status=$?
5384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5385   (exit $ac_status); }; }; then
5386   echo "$as_me:$LINENO: result: yes" >&5
5387 echo "${ECHO_T}yes" >&6
5388 else
5389   echo "$as_me: failed program was:" >&5
5390 sed 's/^/| /' conftest.$ac_ext >&5
5391
5392 echo "$as_me:$LINENO: result: no" >&5
5393 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5394 fi
5395 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5396   CFLAGS="$saved_CFLAGS"
5397 fi
5398
5399 # Flags needed for CLOOG
5400
5401
5402
5403
5404 # By default, C is the only stage 1 language.
5405 stage1_languages=,c,
5406
5407 # Target libraries that we bootstrap.
5408 bootstrap_target_libs=,target-libgcc,
5409
5410 # Figure out what language subdirectories are present.
5411 # Look if the user specified --enable-languages="..."; if not, use
5412 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5413 # go away some day.
5414 # NB:  embedded tabs in this IF block -- do not untabify
5415 if test -d ${srcdir}/gcc; then
5416   if test x"${enable_languages+set}" != xset; then
5417     if test x"${LANGUAGES+set}" = xset; then
5418       enable_languages="${LANGUAGES}"
5419         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5420     else
5421       enable_languages=all
5422     fi
5423   else
5424     if test x"${enable_languages}" = x ||
5425        test x"${enable_languages}" = xyes;
5426        then
5427       echo configure.in: --enable-languages needs at least one language argument 1>&2
5428       exit 1
5429     fi
5430   fi
5431   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5432
5433   # 'f95' is the old name for the 'fortran' language. We issue a warning
5434   # and make the substitution.
5435   case ,${enable_languages}, in
5436     *,f95,*)
5437       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5438       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5439       ;;
5440   esac
5441
5442   # First scan to see if an enabled language requires some other language.
5443   # We assume that a given config-lang.in will list all the language
5444   # front ends it requires, even if some are required indirectly.
5445   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5446     case ${lang_frag} in
5447       ..) ;;
5448       # The odd quoting in the next line works around
5449       # an apparent bug in bash 1.12 on linux.
5450       ${srcdir}/gcc/[*]/config-lang.in) ;;
5451       *)
5452         # From the config-lang.in, get $language, $lang_requires
5453         language=
5454         lang_requires=
5455         . ${lang_frag}
5456         for other in ${lang_requires} ; do
5457           case ,${enable_languages}, in
5458             *,$other,*) ;;
5459             *,all,*) ;;
5460             *,$language,*)
5461               echo " \`$other' language required by \`$language'; enabling" 1>&2
5462               enable_languages="${enable_languages},${other}"
5463               ;;
5464           esac
5465         done
5466         ;;
5467     esac
5468   done
5469
5470   new_enable_languages=,c,
5471   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5472   potential_languages=,c,
5473
5474   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5475     case ${lang_frag} in
5476       ..) ;;
5477       # The odd quoting in the next line works around
5478       # an apparent bug in bash 1.12 on linux.
5479       ${srcdir}/gcc/[*]/config-lang.in) ;;
5480       *)
5481         # From the config-lang.in, get $language, $target_libs,
5482         # $lang_dirs, $boot_language, and $build_by_default
5483         language=
5484         target_libs=
5485         lang_dirs=
5486         subdir_requires=
5487         boot_language=no
5488         build_by_default=yes
5489         . ${lang_frag}
5490         if test x${language} = x; then
5491           echo "${lang_frag} doesn't set \$language." 1>&2
5492           exit 1
5493         fi
5494
5495         if test "$language" = "c++" -a "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5496           boot_language=yes
5497         fi
5498
5499         case ,${enable_languages}, in
5500           *,${language},*)
5501             # Language was explicitly selected; include it.
5502             add_this_lang=yes
5503             ;;
5504           *,all,*)
5505             # 'all' was selected, select it if it is a default language
5506             add_this_lang=${build_by_default}
5507             ;;
5508           *)
5509             add_this_lang=no
5510             ;;
5511         esac
5512
5513         # Disable languages that need other directories if these aren't available.
5514         for i in $subdir_requires; do
5515           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5516           case ,${enable_languages}, in
5517             *,${language},*)
5518               # Specifically requested language; tell them.
5519               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5520 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5521    { (exit 1); exit 1; }; }
5522               ;;
5523             *)
5524               # Silently disable.
5525               add_this_lang=unsupported
5526               ;;
5527           esac
5528         done
5529
5530         # Disable Ada if no preexisting GNAT is available.
5531         case ,${enable_languages},:${language}:${have_gnat} in
5532           *,${language},*:ada:no)
5533             # Specifically requested language; tell them.
5534             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5535 echo "$as_me: error: GNAT is required to build $language" >&2;}
5536    { (exit 1); exit 1; }; }
5537             ;;
5538           *:ada:no)
5539             # Silently disable.
5540             add_this_lang=unsupported
5541             ;;
5542         esac
5543
5544         # Disable a language that is unsupported by the target.
5545         case " $unsupported_languages " in
5546           *" $language "*)
5547             add_this_lang=unsupported
5548             ;;
5549         esac
5550
5551         case $add_this_lang in
5552           unsupported)
5553             # Remove language-dependent dirs.
5554             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5555             ;;
5556           no)
5557             # Remove language-dependent dirs; still show language as supported.
5558             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5559             potential_languages="${potential_languages}${language},"
5560             ;;
5561           yes)
5562             new_enable_languages="${new_enable_languages}${language},"
5563             potential_languages="${potential_languages}${language},"
5564             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5565             case ${boot_language} in
5566               yes)
5567                 # Add to (comma-separated) list of stage 1 languages.
5568                 stage1_languages="${stage1_languages}${language},"
5569                 # We need to bootstrap any supporting libraries.
5570                 bootstrap_target_libs="${bootstrap_target_libs}${target_libs},"
5571                 ;;
5572             esac
5573             ;;
5574         esac
5575         ;;
5576     esac
5577   done
5578
5579   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5580 if test "${enable_stage1_languages+set}" = set; then
5581   enableval="$enable_stage1_languages"
5582   case ,${enable_stage1_languages}, in
5583     ,no,|,,)
5584       # Set it to something that will have no effect in the loop below
5585       enable_stage1_languages=c ;;
5586     ,yes,)
5587       enable_stage1_languages=`echo $new_enable_languages | \
5588         sed -e "s/^,//" -e "s/,$//" ` ;;
5589     *,all,*)
5590       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5591         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5592   esac
5593
5594   # Add "good" languages from enable_stage1_languages to stage1_languages,
5595   # while "bad" languages go in missing_languages.  Leave no duplicates.
5596   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5597     case $potential_languages in
5598       *,$i,*)
5599         case $stage1_languages in
5600           *,$i,*) ;;
5601           *) stage1_languages="$stage1_languages$i," ;;
5602         esac ;;
5603       *)
5604         case $missing_languages in
5605           *,$i,*) ;;
5606           *) missing_languages="$missing_languages$i," ;;
5607         esac ;;
5608      esac
5609   done
5610 fi;
5611
5612   # Remove leading/trailing commas that were added for simplicity
5613   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5614   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5615   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5616   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5617
5618   if test "x$missing_languages" != x; then
5619     { { echo "$as_me:$LINENO: error:
5620 The following requested languages could not be built: ${missing_languages}
5621 Supported languages are: ${potential_languages}" >&5
5622 echo "$as_me: error:
5623 The following requested languages could not be built: ${missing_languages}
5624 Supported languages are: ${potential_languages}" >&2;}
5625    { (exit 1); exit 1; }; }
5626   fi
5627   if test "x$new_enable_languages" != "x$enable_languages"; then
5628     echo The following languages will be built: ${new_enable_languages}
5629     enable_languages="$new_enable_languages"
5630   fi
5631
5632
5633   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5634 fi
5635
5636 # Handle --disable-<component> generically.
5637 for dir in $configdirs $build_configdirs $target_configdirs ; do
5638   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5639   varname=`echo $dirname | sed -e s/+/_/g`
5640   if eval test x\${enable_${varname}} "=" xno ; then
5641     noconfigdirs="$noconfigdirs $dir"
5642   fi
5643 done
5644
5645 # Check for Boehm's garbage collector
5646 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5647 if test "${enable_objc_gc+set}" = set; then
5648   enableval="$enable_objc_gc"
5649   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5650   *,objc,*:*:yes:*target-boehm-gc*)
5651     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5652 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5653    { (exit 1); exit 1; }; }
5654     ;;
5655 esac
5656 fi;
5657
5658 # Make sure we only build Boehm's garbage collector if required.
5659 case ,${enable_languages},:${enable_objc_gc} in
5660   *,objc,*:yes)
5661     # Keep target-boehm-gc if requested for Objective-C.
5662     ;;
5663   *)
5664     # Otherwise remove target-boehm-gc depending on target-libjava.
5665     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5666       noconfigdirs="$noconfigdirs target-boehm-gc"
5667     fi
5668     ;;
5669 esac
5670
5671 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5672 # $build_configdirs and $target_configdirs.
5673 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5674
5675 notsupp=""
5676 for dir in . $skipdirs $noconfigdirs ; do
5677   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5678   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5679     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5680     if test -r $srcdir/$dirname/configure ; then
5681       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5682         true
5683       else
5684         notsupp="$notsupp $dir"
5685       fi
5686     fi
5687   fi
5688   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5689     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5690     if test -r $srcdir/$dirname/configure ; then
5691       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5692         true
5693       else
5694         notsupp="$notsupp $dir"
5695       fi
5696     fi
5697   fi
5698   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5699     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5700     if test -r $srcdir/$dirname/configure ; then
5701       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5702         true
5703       else
5704         notsupp="$notsupp $dir"
5705       fi
5706     fi
5707   fi
5708 done
5709
5710 # Sometimes the tools are distributed with libiberty but with no other
5711 # libraries.  In that case, we don't want to build target-libiberty.
5712 # Don't let libgcc imply libiberty either.
5713 if test -n "${target_configdirs}" ; then
5714   libgcc=
5715   others=
5716   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5717     if test "$i" = "libgcc"; then
5718       libgcc=target-libgcc
5719     elif test "$i" != "libiberty" ; then
5720       if test -r $srcdir/$i/configure ; then
5721         others=yes;
5722         break;
5723       fi
5724     fi
5725   done
5726   if test -z "${others}" ; then
5727     target_configdirs=$libgcc
5728   fi
5729 fi
5730
5731 # Quietly strip out all directories which aren't configurable in this tree.
5732 # This relies on all configurable subdirectories being autoconfiscated, which
5733 # is now the case.
5734 build_configdirs_all="$build_configdirs"
5735 build_configdirs=
5736 for i in ${build_configdirs_all} ; do
5737   j=`echo $i | sed -e s/build-//g`
5738   if test -f ${srcdir}/$j/configure ; then
5739     build_configdirs="${build_configdirs} $i"
5740   fi
5741 done
5742
5743 configdirs_all="$configdirs"
5744 configdirs=
5745 for i in ${configdirs_all} ; do
5746   if test -f ${srcdir}/$i/configure ; then
5747     configdirs="${configdirs} $i"
5748   fi
5749 done
5750
5751 target_configdirs_all="$target_configdirs"
5752 target_configdirs=
5753 for i in ${target_configdirs_all} ; do
5754   j=`echo $i | sed -e s/target-//g`
5755   if test -f ${srcdir}/$j/configure ; then
5756     target_configdirs="${target_configdirs} $i"
5757   fi
5758 done
5759
5760 # Produce a warning message for the subdirs we can't configure.
5761 # This isn't especially interesting in the Cygnus tree, but in the individual
5762 # FSF releases, it's important to let people know when their machine isn't
5763 # supported by the one or two programs in a package.
5764
5765 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5766   # If $appdirs is non-empty, at least one of those directories must still
5767   # be configured, or we error out.  (E.g., if the gas release supports a
5768   # specified target in some subdirs but not the gas subdir, we shouldn't
5769   # pretend that all is well.)
5770   if test -n "$appdirs" ; then
5771     for dir in $appdirs ; do
5772       if test -r $dir/Makefile.in ; then
5773         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5774           appdirs=""
5775           break
5776         fi
5777         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5778           appdirs=""
5779           break
5780         fi
5781       fi
5782     done
5783     if test -n "$appdirs" ; then
5784       echo "*** This configuration is not supported by this package." 1>&2
5785       exit 1
5786     fi
5787   fi
5788   # Okay, some application will build, or we don't care to check.  Still
5789   # notify of subdirs not getting built.
5790   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5791   echo "    ${notsupp}" 1>&2
5792   echo "    (Any other directories should still work fine.)" 1>&2
5793 fi
5794
5795 case "$host" in
5796   *msdosdjgpp*)
5797     enable_gdbtk=no ;;
5798 esac
5799
5800 # To find our prefix, in gcc_cv_tool_prefix.
5801
5802 # The user is always right.
5803 if test "${PATH_SEPARATOR+set}" != set; then
5804   echo "#! /bin/sh" >conf$$.sh
5805   echo  "exit 0"   >>conf$$.sh
5806   chmod +x conf$$.sh
5807   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5808     PATH_SEPARATOR=';'
5809   else
5810     PATH_SEPARATOR=:
5811   fi
5812   rm -f conf$$.sh
5813 fi
5814
5815
5816
5817 if test "x$exec_prefix" = xNONE; then
5818         if test "x$prefix" = xNONE; then
5819                 gcc_cv_tool_prefix=$ac_default_prefix
5820         else
5821                 gcc_cv_tool_prefix=$prefix
5822         fi
5823 else
5824         gcc_cv_tool_prefix=$exec_prefix
5825 fi
5826
5827 # If there is no compiler in the tree, use the PATH only.  In any
5828 # case, if there is no compiler in the tree nobody should use
5829 # AS_FOR_TARGET and LD_FOR_TARGET.
5830 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5831     gcc_version=`cat $srcdir/gcc/BASE-VER`
5832     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5833     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5834     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5835     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5836     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5837     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5838 else
5839     gcc_cv_tool_dirs=
5840 fi
5841
5842 if test x$build = x$target && test -n "$md_exec_prefix"; then
5843         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5844 fi
5845
5846
5847
5848 copy_dirs=
5849
5850
5851 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5852 if test "${with_build_sysroot+set}" = set; then
5853   withval="$with_build_sysroot"
5854   if test x"$withval" != x ; then
5855      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5856    fi
5857 else
5858   SYSROOT_CFLAGS_FOR_TARGET=
5859 fi;
5860
5861
5862
5863 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5864 if test "${with_debug_prefix_map+set}" = set; then
5865   withval="$with_debug_prefix_map"
5866   if test x"$withval" != x; then
5867      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5868      for debug_map in $withval; do
5869        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5870      done
5871    fi
5872 else
5873   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5874 fi;
5875
5876
5877 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5878 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5879 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5880 # We want to ensure that TARGET libraries (which we know are built with
5881 # gcc) are built with "-O2 -g", so include those options when setting
5882 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5883 if test "x$CFLAGS_FOR_TARGET" = x; then
5884   CFLAGS_FOR_TARGET=$CFLAGS
5885   case " $CFLAGS " in
5886     *" -O2 "*) ;;
5887     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5888   esac
5889   case " $CFLAGS " in
5890     *" -g "* | *" -g3 "*) ;;
5891     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5892   esac
5893 fi
5894
5895
5896 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5897   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5898   case " $CXXFLAGS " in
5899     *" -O2 "*) ;;
5900     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5901   esac
5902   case " $CXXFLAGS " in
5903     *" -g "* | *" -g3 "*) ;;
5904     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5905   esac
5906 fi
5907
5908
5909 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5910 # the named directory are copied to $(tooldir)/sys-include.
5911 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5912   if test x${is_cross_compiler} = xno ; then
5913     echo 1>&2 '***' --with-headers is only supported when cross compiling
5914     exit 1
5915   fi
5916   if test x"${with_headers}" != xyes ; then
5917     x=${gcc_cv_tool_prefix}
5918     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5919   fi
5920 fi
5921
5922 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5923 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5924 # are permitted.
5925 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5926   if test x${is_cross_compiler} = xno ; then
5927     echo 1>&2 '***' --with-libs is only supported when cross compiling
5928     exit 1
5929   fi
5930   if test x"${with_libs}" != xyes ; then
5931     # Copy the libraries in reverse order, so that files in the first named
5932     # library override files in subsequent libraries.
5933     x=${gcc_cv_tool_prefix}
5934     for l in ${with_libs}; do
5935       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5936     done
5937   fi
5938 fi
5939
5940 # Set with_gnu_as and with_gnu_ld as appropriate.
5941 #
5942 # This is done by determining whether or not the appropriate directory
5943 # is available, and by checking whether or not specific configurations
5944 # have requested that this magic not happen.
5945 #
5946 # The command line options always override the explicit settings in
5947 # configure.in, and the settings in configure.in override this magic.
5948 #
5949 # If the default for a toolchain is to use GNU as and ld, and you don't
5950 # want to do that, then you should use the --without-gnu-as and
5951 # --without-gnu-ld options for the configure script.
5952
5953 if test x${use_gnu_as} = x &&
5954    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5955   with_gnu_as=yes
5956   extra_host_args="$extra_host_args --with-gnu-as"
5957 fi
5958
5959 if test x${use_gnu_ld} = x &&
5960    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5961   with_gnu_ld=yes
5962   extra_host_args="$extra_host_args --with-gnu-ld"
5963 fi
5964
5965 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5966 # can detect this case.
5967
5968 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5969   with_newlib=yes
5970   extra_host_args="$extra_host_args --with-newlib"
5971 fi
5972
5973 # Handle ${copy_dirs}
5974 set fnord ${copy_dirs}
5975 shift
5976 while test $# != 0 ; do
5977   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5978     :
5979   else
5980     echo Copying $1 to $2
5981
5982     # Use the install script to create the directory and all required
5983     # parent directories.
5984     if test -d $2 ; then
5985       :
5986     else
5987       echo >config.temp
5988       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5989     fi
5990
5991     # Copy the directory, assuming we have tar.
5992     # FIXME: Should we use B in the second tar?  Not all systems support it.
5993     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5994
5995     # It is the responsibility of the user to correctly adjust all
5996     # symlinks.  If somebody can figure out how to handle them correctly
5997     # here, feel free to add the code.
5998
5999     echo $1 > $2/COPIED
6000   fi
6001   shift; shift
6002 done
6003
6004 # Determine a target-dependent exec_prefix that the installed
6005 # gcc will search in.  Keep this list sorted by triplet, with
6006 # the *-*-osname triplets last.
6007 md_exec_prefix=
6008 case "${target}" in
6009   alpha*-*-*vms*)
6010     md_exec_prefix=/gnu/lib/gcc-lib
6011     ;;
6012   i[34567]86-pc-msdosdjgpp*)
6013     md_exec_prefix=/dev/env/DJDIR/bin
6014     ;;
6015   i[34567]86-*-sco3.2v5*)
6016     if test $with_gnu_as = yes; then
6017       md_exec_prefix=/usr/gnu/bin
6018     else
6019       md_exec_prefix=/usr/ccs/bin/elf
6020     fi
6021     ;;
6022
6023   mn10300-*-* | \
6024   powerpc-*-chorusos* | \
6025   powerpc*-*-eabi* | \
6026   powerpc*-*-sysv* | \
6027   powerpc*-*-kaos* | \
6028   s390x-ibm-tpf*)
6029     md_exec_prefix=/usr/ccs/bin
6030     ;;
6031   sparc64-*-elf*)
6032     ;;
6033   v850*-*-*)
6034     md_exec_prefix=/usr/ccs/bin
6035     ;;
6036   xtensa*-*-elf*)
6037     ;;
6038
6039   *-*-beos* | \
6040   *-*-elf* | \
6041   *-*-hpux* | \
6042   *-*-netware* | \
6043   *-*-nto-qnx* | \
6044   *-*-rtems* | \
6045   *-*-solaris2* | \
6046   *-*-sysv[45]* | \
6047   *-*-vxworks* | \
6048   *-wrs-windiss)
6049     md_exec_prefix=/usr/ccs/bin
6050     ;;
6051 esac
6052
6053 extra_arflags_for_target=
6054 extra_nmflags_for_target=
6055 extra_ranlibflags_for_target=
6056 target_makefile_frag=/dev/null
6057 case "${target}" in
6058   mep*-*-*)
6059     target_makefile_frag="config/mt-mep"
6060     ;;
6061   spu-*-*)
6062     target_makefile_frag="config/mt-spu"
6063     ;;
6064   mips*-sde-elf*)
6065     target_makefile_frag="config/mt-sde"
6066     ;;
6067   mipsisa*-*-elfoabi*)
6068     target_makefile_frag="config/mt-mips-elfoabi"
6069     ;;
6070   mips*-*-*linux* | mips*-*-gnu*)
6071     target_makefile_frag="config/mt-mips-gnu"
6072     ;;
6073   *-*-netware*)
6074     target_makefile_frag="config/mt-netware"
6075     ;;
6076   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
6077     target_makefile_frag="config/mt-gnu"
6078     ;;
6079   *-*-aix4.[3456789]* | *-*-aix[56789].*)
6080     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
6081     # commands to handle both 32-bit and 64-bit objects.  These flags are
6082     # harmless if we're using GNU nm or ar.
6083     extra_arflags_for_target=" -X32_64"
6084     extra_nmflags_for_target=" -B -X32_64"
6085     ;;
6086   *-*-darwin*)
6087     # ranlib from Darwin requires the -c flag to look at common symbols.
6088     extra_ranlibflags_for_target=" -c"
6089     ;;
6090   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6091     target_makefile_frag="config/mt-wince"
6092     ;;
6093 esac
6094
6095 alphaieee_frag=/dev/null
6096 case $target in
6097   alpha*-*-*)
6098     # This just makes sure to use the -mieee option to build target libs.
6099     # This should probably be set individually by each library.
6100     alphaieee_frag="config/mt-alphaieee"
6101     ;;
6102 esac
6103
6104 # If --enable-target-optspace always use -Os instead of -O2 to build
6105 # the target libraries, similarly if it is not specified, use -Os
6106 # on selected platforms.
6107 ospace_frag=/dev/null
6108 case "${enable_target_optspace}:${target}" in
6109   yes:*)
6110     ospace_frag="config/mt-ospace"
6111     ;;
6112   :d30v-*)
6113     ospace_frag="config/mt-d30v"
6114     ;;
6115   :m32r-* | :d10v-* | :fr30-*)
6116     ospace_frag="config/mt-ospace"
6117     ;;
6118   no:* | :*)
6119     ;;
6120   *)
6121     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6122     ;;
6123 esac
6124
6125 # Default to using --with-stabs for certain targets.
6126 if test x${with_stabs} = x ; then
6127   case "${target}" in
6128   mips*-*-irix[56]*)
6129     ;;
6130   mips*-*-* | alpha*-*-osf*)
6131     with_stabs=yes;
6132     extra_host_args="${extra_host_args} --with-stabs"
6133     ;;
6134   esac
6135 fi
6136
6137 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6138 # them automatically.
6139 case "${host}" in
6140   hppa*64*-*-hpux11*)
6141     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6142     ;;
6143 esac
6144
6145 # Some systems (e.g., one of the i386-aix systems the gas testers are
6146 # using) don't handle "\$" correctly, so don't use it here.
6147 tooldir='${exec_prefix}'/${target_noncanonical}
6148 build_tooldir=${tooldir}
6149
6150 # Create a .gdbinit file which runs the one in srcdir
6151 # and tells GDB to look there for source files.
6152
6153 if test -r ${srcdir}/.gdbinit ; then
6154   case ${srcdir} in
6155     .) ;;
6156     *) cat > ./.gdbinit <<EOF
6157 # ${NO_EDIT}
6158 dir ${srcdir}
6159 dir .
6160 source ${srcdir}/.gdbinit
6161 EOF
6162     ;;
6163   esac
6164 fi
6165
6166 # Make sure that the compiler is able to generate an executable.  If it
6167 # can't, we are probably in trouble.  We don't care whether we can run the
6168 # executable--we might be using a cross compiler--we only care whether it
6169 # can be created.  At this point the main configure script has set CC.
6170 we_are_ok=no
6171 echo "int main () { return 0; }" > conftest.c
6172 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6173 if test $? = 0 ; then
6174   if test -s conftest || test -s conftest.exe ; then
6175     we_are_ok=yes
6176   fi
6177 fi
6178 case $we_are_ok in
6179   no)
6180     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6181     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6182     rm -f conftest*
6183     exit 1
6184     ;;
6185 esac
6186 rm -f conftest*
6187
6188 # The Solaris /usr/ucb/cc compiler does not appear to work.
6189 case "${host}" in
6190   sparc-sun-solaris2*)
6191       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6192       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6193           could_use=
6194           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6195           if test -d /opt/cygnus/bin ; then
6196               if test "$could_use" = "" ; then
6197                   could_use="/opt/cygnus/bin"
6198               else
6199                   could_use="$could_use or /opt/cygnus/bin"
6200               fi
6201           fi
6202         if test "$could_use" = "" ; then
6203             echo "Warning: compilation may fail because you're using"
6204             echo "/usr/ucb/cc.  You should change your PATH or CC "
6205             echo "variable and rerun configure."
6206         else
6207             echo "Warning: compilation may fail because you're using"
6208             echo "/usr/ucb/cc, when you should use the C compiler from"
6209             echo "$could_use.  You should change your"
6210             echo "PATH or CC variable and rerun configure."
6211         fi
6212       fi
6213   ;;
6214 esac
6215
6216 # Decide which environment variable is used to find dynamic libraries.
6217 case "${host}" in
6218   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6219   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6220   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6221   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6222 esac
6223
6224 # On systems where the dynamic library environment variable is PATH,
6225 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6226 # built executables to PATH.
6227 if test "$RPATH_ENVVAR" = PATH; then
6228   GCC_SHLIB_SUBDIR=/shlib
6229 else
6230   GCC_SHLIB_SUBDIR=
6231 fi
6232
6233 # Record target_configdirs and the configure arguments for target and
6234 # build configuration in Makefile.
6235 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6236 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6237
6238 # Determine whether gdb needs tk/tcl or not.
6239 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6240 # and in that case we want gdb to be built without tk.  Ugh!
6241 # In fact I believe gdb is the *only* package directly dependent on tk,
6242 # so we should be able to put the 'maybe's in unconditionally and
6243 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6244 # 100% sure that that's safe though.
6245
6246 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6247 case "$enable_gdbtk" in
6248   no)
6249     GDB_TK="" ;;
6250   yes)
6251     GDB_TK="${gdb_tk}" ;;
6252   *)
6253     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6254     # distro.  Eventually someone will fix this and move Insight, nee
6255     # gdbtk to a separate directory.
6256     if test -d ${srcdir}/gdb/gdbtk ; then
6257       GDB_TK="${gdb_tk}"
6258     else
6259       GDB_TK=""
6260     fi
6261     ;;
6262 esac
6263 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6264 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6265
6266 # Strip out unwanted targets.
6267
6268 # While at that, we remove Makefiles if we were started for recursive
6269 # configuration, so that the top-level Makefile reconfigures them,
6270 # like we used to do when configure itself was recursive.
6271
6272 # Loop over modules.  $extrasub must be used with care, limiting as
6273 # much as possible the usage of range addresses.  That's because autoconf
6274 # splits the sed script to overcome limits in the number of commands,
6275 # and relying on carefully-timed sed passes may turn out to be very hard
6276 # to maintain later.  In this particular case, you just have to be careful
6277 # not to nest @if/@endif pairs, because configure will not warn you at all.
6278
6279 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6280 if test "${enable_bootstrap+set}" = set; then
6281   enableval="$enable_bootstrap"
6282
6283 else
6284   enable_bootstrap=default
6285 fi;
6286
6287 # Issue errors and warnings for invalid/strange bootstrap combinations.
6288 case "$configdirs" in
6289   *gcc*) have_compiler=yes ;;
6290   *) have_compiler=no ;;
6291 esac
6292
6293 case "$have_compiler:$host:$target:$enable_bootstrap" in
6294   *:*:*:no) ;;
6295
6296   # Default behavior.  Enable bootstrap if we have a compiler
6297   # and we are in a native configuration.
6298   yes:$build:$build:default)
6299     enable_bootstrap=yes ;;
6300
6301   *:*:*:default)
6302     enable_bootstrap=no ;;
6303
6304   # We have a compiler and we are in a native configuration, bootstrap is ok
6305   yes:$build:$build:yes)
6306     ;;
6307
6308   # Other configurations, but we have a compiler.  Assume the user knows
6309   # what he's doing.
6310   yes:*:*:yes)
6311     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6312 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6313     ;;
6314
6315   # No compiler: if they passed --enable-bootstrap explicitly, fail
6316   no:*:*:yes)
6317     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6318 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6319    { (exit 1); exit 1; }; } ;;
6320
6321   # Fail if wrong command line
6322   *)
6323     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6324 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6325    { (exit 1); exit 1; }; }
6326     ;;
6327 esac
6328
6329 # Adjust the toplevel makefile according to whether bootstrap was selected.
6330 case "$enable_bootstrap" in
6331   yes)
6332     bootstrap_suffix=bootstrap ;;
6333   no)
6334     bootstrap_suffix=no-bootstrap ;;
6335 esac
6336
6337 for module in ${build_configdirs} ; do
6338   if test -z "${no_recursion}" \
6339      && test -f ${build_subdir}/${module}/Makefile; then
6340     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6341     rm -f ${build_subdir}/${module}/Makefile
6342   fi
6343   extrasub="$extrasub
6344 /^@if build-$module\$/d
6345 /^@endif build-$module\$/d
6346 /^@if build-$module-$bootstrap_suffix\$/d
6347 /^@endif build-$module-$bootstrap_suffix\$/d"
6348 done
6349 for module in ${configdirs} ; do
6350   if test -z "${no_recursion}"; then
6351     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6352       if test -f ${file}; then
6353         echo 1>&2 "*** removing ${file} to force reconfigure"
6354         rm -f ${file}
6355       fi
6356     done
6357   fi
6358   extrasub="$extrasub
6359 /^@if $module\$/d
6360 /^@endif $module\$/d
6361 /^@if $module-$bootstrap_suffix\$/d
6362 /^@endif $module-$bootstrap_suffix\$/d"
6363 done
6364 for module in ${target_configdirs} ; do
6365   if test -z "${no_recursion}" \
6366      && test -f ${target_subdir}/${module}/Makefile; then
6367     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6368     rm -f ${target_subdir}/${module}/Makefile
6369   fi
6370
6371   # We only bootstrap target libraries listed in bootstrap_target_libs.
6372   case $bootstrap_target_libs in
6373     *,target-$module,*) target_bootstrap_suffix=$bootstrap_suffix ;;
6374     *) target_bootstrap_suffix=no-bootstrap ;;
6375   esac
6376
6377   extrasub="$extrasub
6378 /^@if target-$module\$/d
6379 /^@endif target-$module\$/d
6380 /^@if target-$module-$target_bootstrap_suffix\$/d
6381 /^@endif target-$module-$target_bootstrap_suffix\$/d"
6382 done
6383
6384 extrasub="$extrasub
6385 /^@if /,/^@endif /d"
6386
6387 # Create the serialization dependencies.  This uses a temporary file.
6388
6389 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6390 if test "${enable_serial_configure+set}" = set; then
6391   enableval="$enable_serial_configure"
6392
6393 fi;
6394
6395 case ${enable_serial_configure} in
6396   yes)
6397     enable_serial_build_configure=yes
6398     enable_serial_host_configure=yes
6399     enable_serial_target_configure=yes
6400     ;;
6401 esac
6402
6403 # These force 'configure's to be done one at a time, to avoid problems
6404 # with contention over a shared config.cache.
6405 rm -f serdep.tmp
6406 echo '# serdep.tmp' > serdep.tmp
6407 olditem=
6408 test "x${enable_serial_build_configure}" = xyes &&
6409 for item in ${build_configdirs} ; do
6410   case ${olditem} in
6411     "") ;;
6412     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6413   esac
6414   olditem=${item}
6415 done
6416 olditem=
6417 test "x${enable_serial_host_configure}" = xyes &&
6418 for item in ${configdirs} ; do
6419   case ${olditem} in
6420     "") ;;
6421     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6422   esac
6423   olditem=${item}
6424 done
6425 olditem=
6426 test "x${enable_serial_target_configure}" = xyes &&
6427 for item in ${target_configdirs} ; do
6428   case ${olditem} in
6429     "") ;;
6430     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6431   esac
6432   olditem=${item}
6433 done
6434 serialization_dependencies=serdep.tmp
6435
6436
6437 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6438 # target, nonopt, and variable assignments.  These are the ones we
6439 # might not want to pass down to subconfigures.  Also strip
6440 # program-prefix, program-suffix, and program-transform-name, so that
6441 # we can pass down a consistent program-transform-name.
6442 baseargs=
6443 keep_next=no
6444 skip_next=no
6445 eval "set -- $ac_configure_args"
6446 for ac_arg
6447 do
6448   if test X"$skip_next" = X"yes"; then
6449     skip_next=no
6450     continue
6451   fi
6452   if test X"$keep_next" = X"yes"; then
6453     case $ac_arg in
6454       *\'*)
6455         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6456     esac
6457     baseargs="$baseargs '$ac_arg'"
6458     keep_next=no
6459     continue
6460   fi
6461
6462   # Handle separated arguments.  Based on the logic generated by
6463   # autoconf 2.59.
6464   case $ac_arg in
6465     *=* | --config-cache | -C | -disable-* | --disable-* \
6466       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6467       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6468       | -with-* | --with-* | -without-* | --without-* | --x)
6469       separate_arg=no
6470       ;;
6471     -*)
6472       separate_arg=yes
6473       ;;
6474     *)
6475       separate_arg=no
6476       ;;
6477   esac
6478
6479   case "$ac_arg" in
6480     --no*)
6481       continue
6482       ;;
6483     --c* | \
6484     --sr* | \
6485     --ho* | \
6486     --bu* | \
6487     --t* | \
6488     --program-* | \
6489     -cache_file* | \
6490     -srcdir* | \
6491     -host* | \
6492     -build* | \
6493     -target* | \
6494     -program-prefix* | \
6495     -program-suffix* | \
6496     -program-transform-name* )
6497       skip_next=$separate_arg
6498       continue
6499       ;;
6500     -*)
6501       # An option.  Add it.
6502       case $ac_arg in
6503         *\'*)
6504           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6505       esac
6506       baseargs="$baseargs '$ac_arg'"
6507       keep_next=$separate_arg
6508       ;;
6509     *)
6510       # Either a variable assignment, or a nonopt (triplet).  Don't
6511       # pass it down; let the Makefile handle this.
6512       continue
6513       ;;
6514   esac
6515 done
6516 # Remove the initial space we just introduced and, as these will be
6517 # expanded by make, quote '$'.
6518 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6519
6520 # Add in --program-transform-name, after --program-prefix and
6521 # --program-suffix have been applied to it.  Autoconf has already
6522 # doubled dollar signs and backslashes in program_transform_name; we want
6523 # the backslashes un-doubled, and then the entire thing wrapped in single
6524 # quotes, because this will be expanded first by make and then by the shell.
6525 # Also, because we want to override the logic in subdir configure scripts to
6526 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6527 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6528 ${program_transform_name}
6529 EOF_SED
6530 gcc_transform_name=`cat conftestsed.out`
6531 rm -f conftestsed.out
6532 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6533 if test "$silent" = yes; then
6534   baseargs="$baseargs --silent"
6535 fi
6536
6537 # For the build-side libraries, we just need to pretend we're native,
6538 # and not use the same cache file.  Multilibs are neither needed nor
6539 # desired.
6540 build_configargs="--cache-file=../config.cache ${baseargs}"
6541
6542 # For host modules, accept cache file option, or specification as blank.
6543 case "${cache_file}" in
6544 "") # empty
6545   cache_file_option="" ;;
6546 /* | [A-Za-z]:[\\/]* ) # absolute path
6547   cache_file_option="--cache-file=${cache_file}" ;;
6548 *) # relative path
6549   cache_file_option="--cache-file=../${cache_file}" ;;
6550 esac
6551
6552 # Host dirs don't like to share a cache file either, horribly enough.
6553 # This seems to be due to autoconf 2.5x stupidity.
6554 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6555
6556 target_configargs=${baseargs}
6557
6558 # Passing a --with-cross-host argument lets the target libraries know
6559 # whether they are being built with a cross-compiler or being built
6560 # native.  However, it would be better to use other mechanisms to make the
6561 # sorts of decisions they want to make on this basis.  Please consider
6562 # this option to be deprecated.  FIXME.
6563 if test x${is_cross_compiler} = xyes ; then
6564   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6565 fi
6566
6567 # Default to --enable-multilib.
6568 if test x${enable_multilib} = x ; then
6569   target_configargs="--enable-multilib ${target_configargs}"
6570 fi
6571
6572 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6573 # changed from the earlier setting of with_newlib.
6574 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6575   target_configargs="--with-newlib ${target_configargs}"
6576 fi
6577
6578 # Different target subdirs use different values of certain variables
6579 # (notably CXX).  Worse, multilibs use *lots* of different values.
6580 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6581 # it doesn't automatically accept command-line overrides of them.
6582 # This means it's not safe for target subdirs to share a cache file,
6583 # which is disgusting, but there you have it.  Hopefully this can be
6584 # fixed in future.  It's still worthwhile to use a cache file for each
6585 # directory.  I think.
6586
6587 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6588 # We need to pass --target, as newer autoconf's requires consistency
6589 # for target_alias and gcc doesn't manage it consistently.
6590 target_configargs="--cache-file=./config.cache ${target_configargs}"
6591
6592 FLAGS_FOR_TARGET=
6593 case " $target_configdirs " in
6594  *" newlib "*)
6595   case " $target_configargs " in
6596   *" --with-newlib "*)
6597    case "$target" in
6598    *-cygwin*)
6599      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup -L$$r/$(TARGET_SUBDIR)/winsup/cygwin -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/include -isystem $$s/winsup/cygwin/include -isystem $$s/winsup/w32api/include' ;;
6600    esac
6601
6602    # If we're not building GCC, don't discard standard headers.
6603    if test -d ${srcdir}/gcc; then
6604      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6605
6606      if test "${build}" != "${host}"; then
6607        # On Canadian crosses, CC_FOR_TARGET will have already been set
6608        # by `configure', so we won't have an opportunity to add -Bgcc/
6609        # to it.  This is right: we don't want to search that directory
6610        # for binaries, but we want the header files in there, so add
6611        # them explicitly.
6612        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6613
6614        # Someone might think of using the pre-installed headers on
6615        # Canadian crosses, in case the installed compiler is not fully
6616        # compatible with the compiler being built.  In this case, it
6617        # would be better to flag an error than risking having
6618        # incompatible object files being constructed.  We can't
6619        # guarantee that an error will be flagged, but let's hope the
6620        # compiler will do it, when presented with incompatible header
6621        # files.
6622      fi
6623    fi
6624
6625    case "${target}-${is_cross_compiler}" in
6626    i[3456789]86-*-linux*-no)
6627       # Here host == target, so we don't need to build gcc,
6628       # so we don't want to discard standard headers.
6629       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6630       ;;
6631    *)
6632       # If we're building newlib, use its generic headers last, but search
6633       # for any libc-related directories first (so make it the last -B
6634       # switch).
6635       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6636
6637       # If we're building libgloss, find the startup file, simulator library
6638       # and linker script.
6639       case " $target_configdirs " in
6640         *" libgloss "*)
6641         # Look for startup file, simulator library and maybe linker script.
6642         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6643         # Look for libnosys.a in case the target needs it.
6644         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6645         # Most targets have the linker script in the source directory.
6646         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6647         ;;
6648       esac
6649       ;;
6650    esac
6651    ;;
6652   esac
6653   ;;
6654 esac
6655 case "$target" in
6656 *-mingw*)
6657   # Can't be handled as Cygwin above since Mingw does not use newlib.
6658   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup/mingw -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/mingw/include -isystem $$s/winsup/w32api/include' ;;
6659 esac
6660
6661 # Allow the user to override the flags for
6662 # our build compiler if desired.
6663 if test x"${build}" = x"${host}" ; then
6664   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6665   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6666   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6667 fi
6668
6669 # On Canadian crosses, we'll be searching the right directories for
6670 # the previously-installed cross compiler, so don't bother to add
6671 # flags for directories within the install tree of the compiler
6672 # being built; programs in there won't even run.
6673 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6674   # Search for pre-installed headers if nothing else fits.
6675   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6676 fi
6677
6678 if test "x${use_gnu_ld}" = x &&
6679    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6680   # Arrange for us to find uninstalled linker scripts.
6681   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6682 fi
6683
6684 # Search for other target-specific linker scripts and such.
6685 case "${target}" in
6686   mep*)
6687     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6688     ;;
6689 esac
6690
6691 # Makefile fragments.
6692 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6693 do
6694   eval fragval=\$$frag
6695   if test $fragval != /dev/null; then
6696     eval $frag=${srcdir}/$fragval
6697   fi
6698 done
6699
6700
6701
6702
6703
6704 # Miscellanea: directories, flags, etc.
6705
6706
6707
6708
6709
6710
6711
6712
6713 # Build module lists & subconfigure args.
6714
6715
6716
6717 # Host module lists & subconfigure args.
6718
6719
6720
6721 # Target module lists & subconfigure args.
6722
6723
6724
6725 # Build tools.
6726
6727
6728
6729
6730
6731
6732
6733
6734
6735
6736
6737
6738
6739
6740
6741
6742
6743 # Generate default definitions for YACC, M4, LEX and other programs that run
6744 # on the build machine.  These are used if the Makefile can't locate these
6745 # programs in objdir.
6746 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6747
6748 for ac_prog in 'bison -y' byacc yacc
6749 do
6750   # Extract the first word of "$ac_prog", so it can be a program name with args.
6751 set dummy $ac_prog; ac_word=$2
6752 echo "$as_me:$LINENO: checking for $ac_word" >&5
6753 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6754 if test "${ac_cv_prog_YACC+set}" = set; then
6755   echo $ECHO_N "(cached) $ECHO_C" >&6
6756 else
6757   if test -n "$YACC"; then
6758   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6759 else
6760 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6761 for as_dir in $PATH
6762 do
6763   IFS=$as_save_IFS
6764   test -z "$as_dir" && as_dir=.
6765   for ac_exec_ext in '' $ac_executable_extensions; do
6766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6767     ac_cv_prog_YACC="$ac_prog"
6768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6769     break 2
6770   fi
6771 done
6772 done
6773
6774 fi
6775 fi
6776 YACC=$ac_cv_prog_YACC
6777 if test -n "$YACC"; then
6778   echo "$as_me:$LINENO: result: $YACC" >&5
6779 echo "${ECHO_T}$YACC" >&6
6780 else
6781   echo "$as_me:$LINENO: result: no" >&5
6782 echo "${ECHO_T}no" >&6
6783 fi
6784
6785   test -n "$YACC" && break
6786 done
6787 test -n "$YACC" || YACC="$MISSING bison -y"
6788
6789 case " $build_configdirs " in
6790   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6791   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6792 esac
6793
6794 for ac_prog in bison
6795 do
6796   # Extract the first word of "$ac_prog", so it can be a program name with args.
6797 set dummy $ac_prog; ac_word=$2
6798 echo "$as_me:$LINENO: checking for $ac_word" >&5
6799 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6800 if test "${ac_cv_prog_BISON+set}" = set; then
6801   echo $ECHO_N "(cached) $ECHO_C" >&6
6802 else
6803   if test -n "$BISON"; then
6804   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6805 else
6806 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6807 for as_dir in $PATH
6808 do
6809   IFS=$as_save_IFS
6810   test -z "$as_dir" && as_dir=.
6811   for ac_exec_ext in '' $ac_executable_extensions; do
6812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6813     ac_cv_prog_BISON="$ac_prog"
6814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6815     break 2
6816   fi
6817 done
6818 done
6819
6820 fi
6821 fi
6822 BISON=$ac_cv_prog_BISON
6823 if test -n "$BISON"; then
6824   echo "$as_me:$LINENO: result: $BISON" >&5
6825 echo "${ECHO_T}$BISON" >&6
6826 else
6827   echo "$as_me:$LINENO: result: no" >&5
6828 echo "${ECHO_T}no" >&6
6829 fi
6830
6831   test -n "$BISON" && break
6832 done
6833 test -n "$BISON" || BISON="$MISSING bison"
6834
6835 case " $build_configdirs " in
6836   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6837 esac
6838
6839 for ac_prog in gm4 gnum4 m4
6840 do
6841   # Extract the first word of "$ac_prog", so it can be a program name with args.
6842 set dummy $ac_prog; ac_word=$2
6843 echo "$as_me:$LINENO: checking for $ac_word" >&5
6844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6845 if test "${ac_cv_prog_M4+set}" = set; then
6846   echo $ECHO_N "(cached) $ECHO_C" >&6
6847 else
6848   if test -n "$M4"; then
6849   ac_cv_prog_M4="$M4" # Let the user override the test.
6850 else
6851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6852 for as_dir in $PATH
6853 do
6854   IFS=$as_save_IFS
6855   test -z "$as_dir" && as_dir=.
6856   for ac_exec_ext in '' $ac_executable_extensions; do
6857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6858     ac_cv_prog_M4="$ac_prog"
6859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6860     break 2
6861   fi
6862 done
6863 done
6864
6865 fi
6866 fi
6867 M4=$ac_cv_prog_M4
6868 if test -n "$M4"; then
6869   echo "$as_me:$LINENO: result: $M4" >&5
6870 echo "${ECHO_T}$M4" >&6
6871 else
6872   echo "$as_me:$LINENO: result: no" >&5
6873 echo "${ECHO_T}no" >&6
6874 fi
6875
6876   test -n "$M4" && break
6877 done
6878 test -n "$M4" || M4="$MISSING m4"
6879
6880 case " $build_configdirs " in
6881   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6882 esac
6883
6884 for ac_prog in flex lex
6885 do
6886   # Extract the first word of "$ac_prog", so it can be a program name with args.
6887 set dummy $ac_prog; ac_word=$2
6888 echo "$as_me:$LINENO: checking for $ac_word" >&5
6889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6890 if test "${ac_cv_prog_LEX+set}" = set; then
6891   echo $ECHO_N "(cached) $ECHO_C" >&6
6892 else
6893   if test -n "$LEX"; then
6894   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6895 else
6896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6897 for as_dir in $PATH
6898 do
6899   IFS=$as_save_IFS
6900   test -z "$as_dir" && as_dir=.
6901   for ac_exec_ext in '' $ac_executable_extensions; do
6902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6903     ac_cv_prog_LEX="$ac_prog"
6904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6905     break 2
6906   fi
6907 done
6908 done
6909
6910 fi
6911 fi
6912 LEX=$ac_cv_prog_LEX
6913 if test -n "$LEX"; then
6914   echo "$as_me:$LINENO: result: $LEX" >&5
6915 echo "${ECHO_T}$LEX" >&6
6916 else
6917   echo "$as_me:$LINENO: result: no" >&5
6918 echo "${ECHO_T}no" >&6
6919 fi
6920
6921   test -n "$LEX" && break
6922 done
6923 test -n "$LEX" || LEX="$MISSING flex"
6924
6925 case " $build_configdirs " in
6926   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6927   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6928 esac
6929
6930 for ac_prog in flex
6931 do
6932   # Extract the first word of "$ac_prog", so it can be a program name with args.
6933 set dummy $ac_prog; ac_word=$2
6934 echo "$as_me:$LINENO: checking for $ac_word" >&5
6935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6936 if test "${ac_cv_prog_FLEX+set}" = set; then
6937   echo $ECHO_N "(cached) $ECHO_C" >&6
6938 else
6939   if test -n "$FLEX"; then
6940   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6941 else
6942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6943 for as_dir in $PATH
6944 do
6945   IFS=$as_save_IFS
6946   test -z "$as_dir" && as_dir=.
6947   for ac_exec_ext in '' $ac_executable_extensions; do
6948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6949     ac_cv_prog_FLEX="$ac_prog"
6950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6951     break 2
6952   fi
6953 done
6954 done
6955
6956 fi
6957 fi
6958 FLEX=$ac_cv_prog_FLEX
6959 if test -n "$FLEX"; then
6960   echo "$as_me:$LINENO: result: $FLEX" >&5
6961 echo "${ECHO_T}$FLEX" >&6
6962 else
6963   echo "$as_me:$LINENO: result: no" >&5
6964 echo "${ECHO_T}no" >&6
6965 fi
6966
6967   test -n "$FLEX" && break
6968 done
6969 test -n "$FLEX" || FLEX="$MISSING flex"
6970
6971 case " $build_configdirs " in
6972   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6973 esac
6974
6975 for ac_prog in makeinfo
6976 do
6977   # Extract the first word of "$ac_prog", so it can be a program name with args.
6978 set dummy $ac_prog; ac_word=$2
6979 echo "$as_me:$LINENO: checking for $ac_word" >&5
6980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6981 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6982   echo $ECHO_N "(cached) $ECHO_C" >&6
6983 else
6984   if test -n "$MAKEINFO"; then
6985   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6986 else
6987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6988 for as_dir in $PATH
6989 do
6990   IFS=$as_save_IFS
6991   test -z "$as_dir" && as_dir=.
6992   for ac_exec_ext in '' $ac_executable_extensions; do
6993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6994     ac_cv_prog_MAKEINFO="$ac_prog"
6995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6996     break 2
6997   fi
6998 done
6999 done
7000
7001 fi
7002 fi
7003 MAKEINFO=$ac_cv_prog_MAKEINFO
7004 if test -n "$MAKEINFO"; then
7005   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
7006 echo "${ECHO_T}$MAKEINFO" >&6
7007 else
7008   echo "$as_me:$LINENO: result: no" >&5
7009 echo "${ECHO_T}no" >&6
7010 fi
7011
7012   test -n "$MAKEINFO" && break
7013 done
7014 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
7015
7016 case " $build_configdirs " in
7017   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
7018   *)
7019
7020     # For an installed makeinfo, we require it to be from texinfo 4.7 or
7021     # higher, else we use the "missing" dummy.
7022     if ${MAKEINFO} --version \
7023        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
7024       :
7025     else
7026       MAKEINFO="$MISSING makeinfo"
7027     fi
7028     ;;
7029
7030 esac
7031
7032 # FIXME: expect and dejagnu may become build tools?
7033
7034 for ac_prog in expect
7035 do
7036   # Extract the first word of "$ac_prog", so it can be a program name with args.
7037 set dummy $ac_prog; ac_word=$2
7038 echo "$as_me:$LINENO: checking for $ac_word" >&5
7039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7040 if test "${ac_cv_prog_EXPECT+set}" = set; then
7041   echo $ECHO_N "(cached) $ECHO_C" >&6
7042 else
7043   if test -n "$EXPECT"; then
7044   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
7045 else
7046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7047 for as_dir in $PATH
7048 do
7049   IFS=$as_save_IFS
7050   test -z "$as_dir" && as_dir=.
7051   for ac_exec_ext in '' $ac_executable_extensions; do
7052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7053     ac_cv_prog_EXPECT="$ac_prog"
7054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7055     break 2
7056   fi
7057 done
7058 done
7059
7060 fi
7061 fi
7062 EXPECT=$ac_cv_prog_EXPECT
7063 if test -n "$EXPECT"; then
7064   echo "$as_me:$LINENO: result: $EXPECT" >&5
7065 echo "${ECHO_T}$EXPECT" >&6
7066 else
7067   echo "$as_me:$LINENO: result: no" >&5
7068 echo "${ECHO_T}no" >&6
7069 fi
7070
7071   test -n "$EXPECT" && break
7072 done
7073 test -n "$EXPECT" || EXPECT="expect"
7074
7075 case " $configdirs " in
7076   *" expect "*)
7077     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
7078     ;;
7079 esac
7080
7081 for ac_prog in runtest
7082 do
7083   # Extract the first word of "$ac_prog", so it can be a program name with args.
7084 set dummy $ac_prog; ac_word=$2
7085 echo "$as_me:$LINENO: checking for $ac_word" >&5
7086 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7087 if test "${ac_cv_prog_RUNTEST+set}" = set; then
7088   echo $ECHO_N "(cached) $ECHO_C" >&6
7089 else
7090   if test -n "$RUNTEST"; then
7091   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
7092 else
7093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7094 for as_dir in $PATH
7095 do
7096   IFS=$as_save_IFS
7097   test -z "$as_dir" && as_dir=.
7098   for ac_exec_ext in '' $ac_executable_extensions; do
7099   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7100     ac_cv_prog_RUNTEST="$ac_prog"
7101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7102     break 2
7103   fi
7104 done
7105 done
7106
7107 fi
7108 fi
7109 RUNTEST=$ac_cv_prog_RUNTEST
7110 if test -n "$RUNTEST"; then
7111   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7112 echo "${ECHO_T}$RUNTEST" >&6
7113 else
7114   echo "$as_me:$LINENO: result: no" >&5
7115 echo "${ECHO_T}no" >&6
7116 fi
7117
7118   test -n "$RUNTEST" && break
7119 done
7120 test -n "$RUNTEST" || RUNTEST="runtest"
7121
7122 case " $configdirs " in
7123   *" dejagnu "*)
7124     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7125     ;;
7126 esac
7127
7128
7129 # Host tools.
7130 ncn_tool_prefix=
7131 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7132 ncn_target_tool_prefix=
7133 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7134
7135
7136
7137 if test -n "$AR"; then
7138   ac_cv_prog_AR=$AR
7139 elif test -n "$ac_cv_prog_AR"; then
7140   AR=$ac_cv_prog_AR
7141 fi
7142
7143 if test -n "$ac_cv_prog_AR"; then
7144   for ncn_progname in ar; do
7145     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7146 set dummy ${ncn_progname}; ac_word=$2
7147 echo "$as_me:$LINENO: checking for $ac_word" >&5
7148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7149 if test "${ac_cv_prog_AR+set}" = set; then
7150   echo $ECHO_N "(cached) $ECHO_C" >&6
7151 else
7152   if test -n "$AR"; then
7153   ac_cv_prog_AR="$AR" # Let the user override the test.
7154 else
7155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7156 for as_dir in $PATH
7157 do
7158   IFS=$as_save_IFS
7159   test -z "$as_dir" && as_dir=.
7160   for ac_exec_ext in '' $ac_executable_extensions; do
7161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7162     ac_cv_prog_AR="${ncn_progname}"
7163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7164     break 2
7165   fi
7166 done
7167 done
7168
7169 fi
7170 fi
7171 AR=$ac_cv_prog_AR
7172 if test -n "$AR"; then
7173   echo "$as_me:$LINENO: result: $AR" >&5
7174 echo "${ECHO_T}$AR" >&6
7175 else
7176   echo "$as_me:$LINENO: result: no" >&5
7177 echo "${ECHO_T}no" >&6
7178 fi
7179
7180   done
7181 fi
7182
7183 for ncn_progname in ar; do
7184   if test -n "$ncn_tool_prefix"; then
7185     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7186 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7187 echo "$as_me:$LINENO: checking for $ac_word" >&5
7188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7189 if test "${ac_cv_prog_AR+set}" = set; then
7190   echo $ECHO_N "(cached) $ECHO_C" >&6
7191 else
7192   if test -n "$AR"; then
7193   ac_cv_prog_AR="$AR" # Let the user override the test.
7194 else
7195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7196 for as_dir in $PATH
7197 do
7198   IFS=$as_save_IFS
7199   test -z "$as_dir" && as_dir=.
7200   for ac_exec_ext in '' $ac_executable_extensions; do
7201   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7202     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7203     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7204     break 2
7205   fi
7206 done
7207 done
7208
7209 fi
7210 fi
7211 AR=$ac_cv_prog_AR
7212 if test -n "$AR"; then
7213   echo "$as_me:$LINENO: result: $AR" >&5
7214 echo "${ECHO_T}$AR" >&6
7215 else
7216   echo "$as_me:$LINENO: result: no" >&5
7217 echo "${ECHO_T}no" >&6
7218 fi
7219
7220   fi
7221   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7222     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7223 set dummy ${ncn_progname}; ac_word=$2
7224 echo "$as_me:$LINENO: checking for $ac_word" >&5
7225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7226 if test "${ac_cv_prog_AR+set}" = set; then
7227   echo $ECHO_N "(cached) $ECHO_C" >&6
7228 else
7229   if test -n "$AR"; then
7230   ac_cv_prog_AR="$AR" # Let the user override the test.
7231 else
7232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7233 for as_dir in $PATH
7234 do
7235   IFS=$as_save_IFS
7236   test -z "$as_dir" && as_dir=.
7237   for ac_exec_ext in '' $ac_executable_extensions; do
7238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7239     ac_cv_prog_AR="${ncn_progname}"
7240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7241     break 2
7242   fi
7243 done
7244 done
7245
7246 fi
7247 fi
7248 AR=$ac_cv_prog_AR
7249 if test -n "$AR"; then
7250   echo "$as_me:$LINENO: result: $AR" >&5
7251 echo "${ECHO_T}$AR" >&6
7252 else
7253   echo "$as_me:$LINENO: result: no" >&5
7254 echo "${ECHO_T}no" >&6
7255 fi
7256
7257   fi
7258   test -n "$ac_cv_prog_AR" && break
7259 done
7260
7261 if test -z "$ac_cv_prog_AR" ; then
7262   set dummy ar
7263   if test $build = $host ; then
7264     AR="$2"
7265   else
7266     AR="${ncn_tool_prefix}$2"
7267   fi
7268 fi
7269
7270
7271
7272 if test -n "$AS"; then
7273   ac_cv_prog_AS=$AS
7274 elif test -n "$ac_cv_prog_AS"; then
7275   AS=$ac_cv_prog_AS
7276 fi
7277
7278 if test -n "$ac_cv_prog_AS"; then
7279   for ncn_progname in as; do
7280     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7281 set dummy ${ncn_progname}; ac_word=$2
7282 echo "$as_me:$LINENO: checking for $ac_word" >&5
7283 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7284 if test "${ac_cv_prog_AS+set}" = set; then
7285   echo $ECHO_N "(cached) $ECHO_C" >&6
7286 else
7287   if test -n "$AS"; then
7288   ac_cv_prog_AS="$AS" # Let the user override the test.
7289 else
7290 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7291 for as_dir in $PATH
7292 do
7293   IFS=$as_save_IFS
7294   test -z "$as_dir" && as_dir=.
7295   for ac_exec_ext in '' $ac_executable_extensions; do
7296   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7297     ac_cv_prog_AS="${ncn_progname}"
7298     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7299     break 2
7300   fi
7301 done
7302 done
7303
7304 fi
7305 fi
7306 AS=$ac_cv_prog_AS
7307 if test -n "$AS"; then
7308   echo "$as_me:$LINENO: result: $AS" >&5
7309 echo "${ECHO_T}$AS" >&6
7310 else
7311   echo "$as_me:$LINENO: result: no" >&5
7312 echo "${ECHO_T}no" >&6
7313 fi
7314
7315   done
7316 fi
7317
7318 for ncn_progname in as; do
7319   if test -n "$ncn_tool_prefix"; then
7320     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7321 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7322 echo "$as_me:$LINENO: checking for $ac_word" >&5
7323 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7324 if test "${ac_cv_prog_AS+set}" = set; then
7325   echo $ECHO_N "(cached) $ECHO_C" >&6
7326 else
7327   if test -n "$AS"; then
7328   ac_cv_prog_AS="$AS" # Let the user override the test.
7329 else
7330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7331 for as_dir in $PATH
7332 do
7333   IFS=$as_save_IFS
7334   test -z "$as_dir" && as_dir=.
7335   for ac_exec_ext in '' $ac_executable_extensions; do
7336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7337     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7339     break 2
7340   fi
7341 done
7342 done
7343
7344 fi
7345 fi
7346 AS=$ac_cv_prog_AS
7347 if test -n "$AS"; then
7348   echo "$as_me:$LINENO: result: $AS" >&5
7349 echo "${ECHO_T}$AS" >&6
7350 else
7351   echo "$as_me:$LINENO: result: no" >&5
7352 echo "${ECHO_T}no" >&6
7353 fi
7354
7355   fi
7356   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7357     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7358 set dummy ${ncn_progname}; ac_word=$2
7359 echo "$as_me:$LINENO: checking for $ac_word" >&5
7360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7361 if test "${ac_cv_prog_AS+set}" = set; then
7362   echo $ECHO_N "(cached) $ECHO_C" >&6
7363 else
7364   if test -n "$AS"; then
7365   ac_cv_prog_AS="$AS" # Let the user override the test.
7366 else
7367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7368 for as_dir in $PATH
7369 do
7370   IFS=$as_save_IFS
7371   test -z "$as_dir" && as_dir=.
7372   for ac_exec_ext in '' $ac_executable_extensions; do
7373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7374     ac_cv_prog_AS="${ncn_progname}"
7375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7376     break 2
7377   fi
7378 done
7379 done
7380
7381 fi
7382 fi
7383 AS=$ac_cv_prog_AS
7384 if test -n "$AS"; then
7385   echo "$as_me:$LINENO: result: $AS" >&5
7386 echo "${ECHO_T}$AS" >&6
7387 else
7388   echo "$as_me:$LINENO: result: no" >&5
7389 echo "${ECHO_T}no" >&6
7390 fi
7391
7392   fi
7393   test -n "$ac_cv_prog_AS" && break
7394 done
7395
7396 if test -z "$ac_cv_prog_AS" ; then
7397   set dummy as
7398   if test $build = $host ; then
7399     AS="$2"
7400   else
7401     AS="${ncn_tool_prefix}$2"
7402   fi
7403 fi
7404
7405
7406
7407 if test -n "$DLLTOOL"; then
7408   ac_cv_prog_DLLTOOL=$DLLTOOL
7409 elif test -n "$ac_cv_prog_DLLTOOL"; then
7410   DLLTOOL=$ac_cv_prog_DLLTOOL
7411 fi
7412
7413 if test -n "$ac_cv_prog_DLLTOOL"; then
7414   for ncn_progname in dlltool; do
7415     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7416 set dummy ${ncn_progname}; ac_word=$2
7417 echo "$as_me:$LINENO: checking for $ac_word" >&5
7418 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7419 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7420   echo $ECHO_N "(cached) $ECHO_C" >&6
7421 else
7422   if test -n "$DLLTOOL"; then
7423   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7424 else
7425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7426 for as_dir in $PATH
7427 do
7428   IFS=$as_save_IFS
7429   test -z "$as_dir" && as_dir=.
7430   for ac_exec_ext in '' $ac_executable_extensions; do
7431   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7432     ac_cv_prog_DLLTOOL="${ncn_progname}"
7433     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7434     break 2
7435   fi
7436 done
7437 done
7438
7439 fi
7440 fi
7441 DLLTOOL=$ac_cv_prog_DLLTOOL
7442 if test -n "$DLLTOOL"; then
7443   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7444 echo "${ECHO_T}$DLLTOOL" >&6
7445 else
7446   echo "$as_me:$LINENO: result: no" >&5
7447 echo "${ECHO_T}no" >&6
7448 fi
7449
7450   done
7451 fi
7452
7453 for ncn_progname in dlltool; do
7454   if test -n "$ncn_tool_prefix"; then
7455     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7456 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7457 echo "$as_me:$LINENO: checking for $ac_word" >&5
7458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7459 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7460   echo $ECHO_N "(cached) $ECHO_C" >&6
7461 else
7462   if test -n "$DLLTOOL"; then
7463   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7464 else
7465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7466 for as_dir in $PATH
7467 do
7468   IFS=$as_save_IFS
7469   test -z "$as_dir" && as_dir=.
7470   for ac_exec_ext in '' $ac_executable_extensions; do
7471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7472     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7474     break 2
7475   fi
7476 done
7477 done
7478
7479 fi
7480 fi
7481 DLLTOOL=$ac_cv_prog_DLLTOOL
7482 if test -n "$DLLTOOL"; then
7483   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7484 echo "${ECHO_T}$DLLTOOL" >&6
7485 else
7486   echo "$as_me:$LINENO: result: no" >&5
7487 echo "${ECHO_T}no" >&6
7488 fi
7489
7490   fi
7491   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7492     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7493 set dummy ${ncn_progname}; ac_word=$2
7494 echo "$as_me:$LINENO: checking for $ac_word" >&5
7495 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7496 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7497   echo $ECHO_N "(cached) $ECHO_C" >&6
7498 else
7499   if test -n "$DLLTOOL"; then
7500   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7501 else
7502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7503 for as_dir in $PATH
7504 do
7505   IFS=$as_save_IFS
7506   test -z "$as_dir" && as_dir=.
7507   for ac_exec_ext in '' $ac_executable_extensions; do
7508   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7509     ac_cv_prog_DLLTOOL="${ncn_progname}"
7510     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7511     break 2
7512   fi
7513 done
7514 done
7515
7516 fi
7517 fi
7518 DLLTOOL=$ac_cv_prog_DLLTOOL
7519 if test -n "$DLLTOOL"; then
7520   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7521 echo "${ECHO_T}$DLLTOOL" >&6
7522 else
7523   echo "$as_me:$LINENO: result: no" >&5
7524 echo "${ECHO_T}no" >&6
7525 fi
7526
7527   fi
7528   test -n "$ac_cv_prog_DLLTOOL" && break
7529 done
7530
7531 if test -z "$ac_cv_prog_DLLTOOL" ; then
7532   set dummy dlltool
7533   if test $build = $host ; then
7534     DLLTOOL="$2"
7535   else
7536     DLLTOOL="${ncn_tool_prefix}$2"
7537   fi
7538 fi
7539
7540
7541
7542 if test -n "$LD"; then
7543   ac_cv_prog_LD=$LD
7544 elif test -n "$ac_cv_prog_LD"; then
7545   LD=$ac_cv_prog_LD
7546 fi
7547
7548 if test -n "$ac_cv_prog_LD"; then
7549   for ncn_progname in ld; do
7550     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7551 set dummy ${ncn_progname}; ac_word=$2
7552 echo "$as_me:$LINENO: checking for $ac_word" >&5
7553 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7554 if test "${ac_cv_prog_LD+set}" = set; then
7555   echo $ECHO_N "(cached) $ECHO_C" >&6
7556 else
7557   if test -n "$LD"; then
7558   ac_cv_prog_LD="$LD" # Let the user override the test.
7559 else
7560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7561 for as_dir in $PATH
7562 do
7563   IFS=$as_save_IFS
7564   test -z "$as_dir" && as_dir=.
7565   for ac_exec_ext in '' $ac_executable_extensions; do
7566   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7567     ac_cv_prog_LD="${ncn_progname}"
7568     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7569     break 2
7570   fi
7571 done
7572 done
7573
7574 fi
7575 fi
7576 LD=$ac_cv_prog_LD
7577 if test -n "$LD"; then
7578   echo "$as_me:$LINENO: result: $LD" >&5
7579 echo "${ECHO_T}$LD" >&6
7580 else
7581   echo "$as_me:$LINENO: result: no" >&5
7582 echo "${ECHO_T}no" >&6
7583 fi
7584
7585   done
7586 fi
7587
7588 for ncn_progname in ld; do
7589   if test -n "$ncn_tool_prefix"; then
7590     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7591 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7592 echo "$as_me:$LINENO: checking for $ac_word" >&5
7593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7594 if test "${ac_cv_prog_LD+set}" = set; then
7595   echo $ECHO_N "(cached) $ECHO_C" >&6
7596 else
7597   if test -n "$LD"; then
7598   ac_cv_prog_LD="$LD" # Let the user override the test.
7599 else
7600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7601 for as_dir in $PATH
7602 do
7603   IFS=$as_save_IFS
7604   test -z "$as_dir" && as_dir=.
7605   for ac_exec_ext in '' $ac_executable_extensions; do
7606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7607     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7609     break 2
7610   fi
7611 done
7612 done
7613
7614 fi
7615 fi
7616 LD=$ac_cv_prog_LD
7617 if test -n "$LD"; then
7618   echo "$as_me:$LINENO: result: $LD" >&5
7619 echo "${ECHO_T}$LD" >&6
7620 else
7621   echo "$as_me:$LINENO: result: no" >&5
7622 echo "${ECHO_T}no" >&6
7623 fi
7624
7625   fi
7626   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7627     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7628 set dummy ${ncn_progname}; ac_word=$2
7629 echo "$as_me:$LINENO: checking for $ac_word" >&5
7630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7631 if test "${ac_cv_prog_LD+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test -n "$LD"; then
7635   ac_cv_prog_LD="$LD" # Let the user override the test.
7636 else
7637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7638 for as_dir in $PATH
7639 do
7640   IFS=$as_save_IFS
7641   test -z "$as_dir" && as_dir=.
7642   for ac_exec_ext in '' $ac_executable_extensions; do
7643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7644     ac_cv_prog_LD="${ncn_progname}"
7645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7646     break 2
7647   fi
7648 done
7649 done
7650
7651 fi
7652 fi
7653 LD=$ac_cv_prog_LD
7654 if test -n "$LD"; then
7655   echo "$as_me:$LINENO: result: $LD" >&5
7656 echo "${ECHO_T}$LD" >&6
7657 else
7658   echo "$as_me:$LINENO: result: no" >&5
7659 echo "${ECHO_T}no" >&6
7660 fi
7661
7662   fi
7663   test -n "$ac_cv_prog_LD" && break
7664 done
7665
7666 if test -z "$ac_cv_prog_LD" ; then
7667   set dummy ld
7668   if test $build = $host ; then
7669     LD="$2"
7670   else
7671     LD="${ncn_tool_prefix}$2"
7672   fi
7673 fi
7674
7675
7676
7677 if test -n "$LIPO"; then
7678   ac_cv_prog_LIPO=$LIPO
7679 elif test -n "$ac_cv_prog_LIPO"; then
7680   LIPO=$ac_cv_prog_LIPO
7681 fi
7682
7683 if test -n "$ac_cv_prog_LIPO"; then
7684   for ncn_progname in lipo; do
7685     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7686 set dummy ${ncn_progname}; ac_word=$2
7687 echo "$as_me:$LINENO: checking for $ac_word" >&5
7688 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7689 if test "${ac_cv_prog_LIPO+set}" = set; then
7690   echo $ECHO_N "(cached) $ECHO_C" >&6
7691 else
7692   if test -n "$LIPO"; then
7693   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7694 else
7695 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7696 for as_dir in $PATH
7697 do
7698   IFS=$as_save_IFS
7699   test -z "$as_dir" && as_dir=.
7700   for ac_exec_ext in '' $ac_executable_extensions; do
7701   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7702     ac_cv_prog_LIPO="${ncn_progname}"
7703     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7704     break 2
7705   fi
7706 done
7707 done
7708
7709 fi
7710 fi
7711 LIPO=$ac_cv_prog_LIPO
7712 if test -n "$LIPO"; then
7713   echo "$as_me:$LINENO: result: $LIPO" >&5
7714 echo "${ECHO_T}$LIPO" >&6
7715 else
7716   echo "$as_me:$LINENO: result: no" >&5
7717 echo "${ECHO_T}no" >&6
7718 fi
7719
7720   done
7721 fi
7722
7723 for ncn_progname in lipo; do
7724   if test -n "$ncn_tool_prefix"; then
7725     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7726 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7727 echo "$as_me:$LINENO: checking for $ac_word" >&5
7728 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7729 if test "${ac_cv_prog_LIPO+set}" = set; then
7730   echo $ECHO_N "(cached) $ECHO_C" >&6
7731 else
7732   if test -n "$LIPO"; then
7733   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7734 else
7735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7736 for as_dir in $PATH
7737 do
7738   IFS=$as_save_IFS
7739   test -z "$as_dir" && as_dir=.
7740   for ac_exec_ext in '' $ac_executable_extensions; do
7741   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7742     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7743     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7744     break 2
7745   fi
7746 done
7747 done
7748
7749 fi
7750 fi
7751 LIPO=$ac_cv_prog_LIPO
7752 if test -n "$LIPO"; then
7753   echo "$as_me:$LINENO: result: $LIPO" >&5
7754 echo "${ECHO_T}$LIPO" >&6
7755 else
7756   echo "$as_me:$LINENO: result: no" >&5
7757 echo "${ECHO_T}no" >&6
7758 fi
7759
7760   fi
7761   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7762     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7763 set dummy ${ncn_progname}; ac_word=$2
7764 echo "$as_me:$LINENO: checking for $ac_word" >&5
7765 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7766 if test "${ac_cv_prog_LIPO+set}" = set; then
7767   echo $ECHO_N "(cached) $ECHO_C" >&6
7768 else
7769   if test -n "$LIPO"; then
7770   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7771 else
7772 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7773 for as_dir in $PATH
7774 do
7775   IFS=$as_save_IFS
7776   test -z "$as_dir" && as_dir=.
7777   for ac_exec_ext in '' $ac_executable_extensions; do
7778   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7779     ac_cv_prog_LIPO="${ncn_progname}"
7780     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7781     break 2
7782   fi
7783 done
7784 done
7785
7786 fi
7787 fi
7788 LIPO=$ac_cv_prog_LIPO
7789 if test -n "$LIPO"; then
7790   echo "$as_me:$LINENO: result: $LIPO" >&5
7791 echo "${ECHO_T}$LIPO" >&6
7792 else
7793   echo "$as_me:$LINENO: result: no" >&5
7794 echo "${ECHO_T}no" >&6
7795 fi
7796
7797   fi
7798   test -n "$ac_cv_prog_LIPO" && break
7799 done
7800
7801 if test -z "$ac_cv_prog_LIPO" ; then
7802   set dummy lipo
7803   if test $build = $host ; then
7804     LIPO="$2"
7805   else
7806     LIPO="${ncn_tool_prefix}$2"
7807   fi
7808 fi
7809
7810
7811
7812 if test -n "$NM"; then
7813   ac_cv_prog_NM=$NM
7814 elif test -n "$ac_cv_prog_NM"; then
7815   NM=$ac_cv_prog_NM
7816 fi
7817
7818 if test -n "$ac_cv_prog_NM"; then
7819   for ncn_progname in nm; do
7820     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7821 set dummy ${ncn_progname}; ac_word=$2
7822 echo "$as_me:$LINENO: checking for $ac_word" >&5
7823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7824 if test "${ac_cv_prog_NM+set}" = set; then
7825   echo $ECHO_N "(cached) $ECHO_C" >&6
7826 else
7827   if test -n "$NM"; then
7828   ac_cv_prog_NM="$NM" # Let the user override the test.
7829 else
7830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7831 for as_dir in $PATH
7832 do
7833   IFS=$as_save_IFS
7834   test -z "$as_dir" && as_dir=.
7835   for ac_exec_ext in '' $ac_executable_extensions; do
7836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7837     ac_cv_prog_NM="${ncn_progname}"
7838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7839     break 2
7840   fi
7841 done
7842 done
7843
7844 fi
7845 fi
7846 NM=$ac_cv_prog_NM
7847 if test -n "$NM"; then
7848   echo "$as_me:$LINENO: result: $NM" >&5
7849 echo "${ECHO_T}$NM" >&6
7850 else
7851   echo "$as_me:$LINENO: result: no" >&5
7852 echo "${ECHO_T}no" >&6
7853 fi
7854
7855   done
7856 fi
7857
7858 for ncn_progname in nm; do
7859   if test -n "$ncn_tool_prefix"; then
7860     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7861 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7862 echo "$as_me:$LINENO: checking for $ac_word" >&5
7863 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7864 if test "${ac_cv_prog_NM+set}" = set; then
7865   echo $ECHO_N "(cached) $ECHO_C" >&6
7866 else
7867   if test -n "$NM"; then
7868   ac_cv_prog_NM="$NM" # Let the user override the test.
7869 else
7870 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7871 for as_dir in $PATH
7872 do
7873   IFS=$as_save_IFS
7874   test -z "$as_dir" && as_dir=.
7875   for ac_exec_ext in '' $ac_executable_extensions; do
7876   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7877     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7878     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7879     break 2
7880   fi
7881 done
7882 done
7883
7884 fi
7885 fi
7886 NM=$ac_cv_prog_NM
7887 if test -n "$NM"; then
7888   echo "$as_me:$LINENO: result: $NM" >&5
7889 echo "${ECHO_T}$NM" >&6
7890 else
7891   echo "$as_me:$LINENO: result: no" >&5
7892 echo "${ECHO_T}no" >&6
7893 fi
7894
7895   fi
7896   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7897     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7898 set dummy ${ncn_progname}; ac_word=$2
7899 echo "$as_me:$LINENO: checking for $ac_word" >&5
7900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7901 if test "${ac_cv_prog_NM+set}" = set; then
7902   echo $ECHO_N "(cached) $ECHO_C" >&6
7903 else
7904   if test -n "$NM"; then
7905   ac_cv_prog_NM="$NM" # Let the user override the test.
7906 else
7907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7908 for as_dir in $PATH
7909 do
7910   IFS=$as_save_IFS
7911   test -z "$as_dir" && as_dir=.
7912   for ac_exec_ext in '' $ac_executable_extensions; do
7913   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7914     ac_cv_prog_NM="${ncn_progname}"
7915     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7916     break 2
7917   fi
7918 done
7919 done
7920
7921 fi
7922 fi
7923 NM=$ac_cv_prog_NM
7924 if test -n "$NM"; then
7925   echo "$as_me:$LINENO: result: $NM" >&5
7926 echo "${ECHO_T}$NM" >&6
7927 else
7928   echo "$as_me:$LINENO: result: no" >&5
7929 echo "${ECHO_T}no" >&6
7930 fi
7931
7932   fi
7933   test -n "$ac_cv_prog_NM" && break
7934 done
7935
7936 if test -z "$ac_cv_prog_NM" ; then
7937   set dummy nm
7938   if test $build = $host ; then
7939     NM="$2"
7940   else
7941     NM="${ncn_tool_prefix}$2"
7942   fi
7943 fi
7944
7945
7946
7947 if test -n "$RANLIB"; then
7948   ac_cv_prog_RANLIB=$RANLIB
7949 elif test -n "$ac_cv_prog_RANLIB"; then
7950   RANLIB=$ac_cv_prog_RANLIB
7951 fi
7952
7953 if test -n "$ac_cv_prog_RANLIB"; then
7954   for ncn_progname in ranlib; do
7955     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7956 set dummy ${ncn_progname}; ac_word=$2
7957 echo "$as_me:$LINENO: checking for $ac_word" >&5
7958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7959 if test "${ac_cv_prog_RANLIB+set}" = set; then
7960   echo $ECHO_N "(cached) $ECHO_C" >&6
7961 else
7962   if test -n "$RANLIB"; then
7963   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7964 else
7965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7966 for as_dir in $PATH
7967 do
7968   IFS=$as_save_IFS
7969   test -z "$as_dir" && as_dir=.
7970   for ac_exec_ext in '' $ac_executable_extensions; do
7971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7972     ac_cv_prog_RANLIB="${ncn_progname}"
7973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7974     break 2
7975   fi
7976 done
7977 done
7978
7979 fi
7980 fi
7981 RANLIB=$ac_cv_prog_RANLIB
7982 if test -n "$RANLIB"; then
7983   echo "$as_me:$LINENO: result: $RANLIB" >&5
7984 echo "${ECHO_T}$RANLIB" >&6
7985 else
7986   echo "$as_me:$LINENO: result: no" >&5
7987 echo "${ECHO_T}no" >&6
7988 fi
7989
7990   done
7991 fi
7992
7993 for ncn_progname in ranlib; do
7994   if test -n "$ncn_tool_prefix"; then
7995     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7996 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7997 echo "$as_me:$LINENO: checking for $ac_word" >&5
7998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7999 if test "${ac_cv_prog_RANLIB+set}" = set; then
8000   echo $ECHO_N "(cached) $ECHO_C" >&6
8001 else
8002   if test -n "$RANLIB"; then
8003   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8004 else
8005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8006 for as_dir in $PATH
8007 do
8008   IFS=$as_save_IFS
8009   test -z "$as_dir" && as_dir=.
8010   for ac_exec_ext in '' $ac_executable_extensions; do
8011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8012     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
8013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8014     break 2
8015   fi
8016 done
8017 done
8018
8019 fi
8020 fi
8021 RANLIB=$ac_cv_prog_RANLIB
8022 if test -n "$RANLIB"; then
8023   echo "$as_me:$LINENO: result: $RANLIB" >&5
8024 echo "${ECHO_T}$RANLIB" >&6
8025 else
8026   echo "$as_me:$LINENO: result: no" >&5
8027 echo "${ECHO_T}no" >&6
8028 fi
8029
8030   fi
8031   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
8032     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8033 set dummy ${ncn_progname}; ac_word=$2
8034 echo "$as_me:$LINENO: checking for $ac_word" >&5
8035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8036 if test "${ac_cv_prog_RANLIB+set}" = set; then
8037   echo $ECHO_N "(cached) $ECHO_C" >&6
8038 else
8039   if test -n "$RANLIB"; then
8040   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8041 else
8042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8043 for as_dir in $PATH
8044 do
8045   IFS=$as_save_IFS
8046   test -z "$as_dir" && as_dir=.
8047   for ac_exec_ext in '' $ac_executable_extensions; do
8048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8049     ac_cv_prog_RANLIB="${ncn_progname}"
8050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8051     break 2
8052   fi
8053 done
8054 done
8055
8056 fi
8057 fi
8058 RANLIB=$ac_cv_prog_RANLIB
8059 if test -n "$RANLIB"; then
8060   echo "$as_me:$LINENO: result: $RANLIB" >&5
8061 echo "${ECHO_T}$RANLIB" >&6
8062 else
8063   echo "$as_me:$LINENO: result: no" >&5
8064 echo "${ECHO_T}no" >&6
8065 fi
8066
8067   fi
8068   test -n "$ac_cv_prog_RANLIB" && break
8069 done
8070
8071 if test -z "$ac_cv_prog_RANLIB" ; then
8072   RANLIB=":"
8073 fi
8074
8075
8076
8077 if test -n "$STRIP"; then
8078   ac_cv_prog_STRIP=$STRIP
8079 elif test -n "$ac_cv_prog_STRIP"; then
8080   STRIP=$ac_cv_prog_STRIP
8081 fi
8082
8083 if test -n "$ac_cv_prog_STRIP"; then
8084   for ncn_progname in strip; do
8085     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8086 set dummy ${ncn_progname}; ac_word=$2
8087 echo "$as_me:$LINENO: checking for $ac_word" >&5
8088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8089 if test "${ac_cv_prog_STRIP+set}" = set; then
8090   echo $ECHO_N "(cached) $ECHO_C" >&6
8091 else
8092   if test -n "$STRIP"; then
8093   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8094 else
8095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8096 for as_dir in $PATH
8097 do
8098   IFS=$as_save_IFS
8099   test -z "$as_dir" && as_dir=.
8100   for ac_exec_ext in '' $ac_executable_extensions; do
8101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8102     ac_cv_prog_STRIP="${ncn_progname}"
8103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8104     break 2
8105   fi
8106 done
8107 done
8108
8109 fi
8110 fi
8111 STRIP=$ac_cv_prog_STRIP
8112 if test -n "$STRIP"; then
8113   echo "$as_me:$LINENO: result: $STRIP" >&5
8114 echo "${ECHO_T}$STRIP" >&6
8115 else
8116   echo "$as_me:$LINENO: result: no" >&5
8117 echo "${ECHO_T}no" >&6
8118 fi
8119
8120   done
8121 fi
8122
8123 for ncn_progname in strip; do
8124   if test -n "$ncn_tool_prefix"; then
8125     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8126 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8127 echo "$as_me:$LINENO: checking for $ac_word" >&5
8128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8129 if test "${ac_cv_prog_STRIP+set}" = set; then
8130   echo $ECHO_N "(cached) $ECHO_C" >&6
8131 else
8132   if test -n "$STRIP"; then
8133   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8134 else
8135 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8136 for as_dir in $PATH
8137 do
8138   IFS=$as_save_IFS
8139   test -z "$as_dir" && as_dir=.
8140   for ac_exec_ext in '' $ac_executable_extensions; do
8141   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8142     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8144     break 2
8145   fi
8146 done
8147 done
8148
8149 fi
8150 fi
8151 STRIP=$ac_cv_prog_STRIP
8152 if test -n "$STRIP"; then
8153   echo "$as_me:$LINENO: result: $STRIP" >&5
8154 echo "${ECHO_T}$STRIP" >&6
8155 else
8156   echo "$as_me:$LINENO: result: no" >&5
8157 echo "${ECHO_T}no" >&6
8158 fi
8159
8160   fi
8161   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8162     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8163 set dummy ${ncn_progname}; ac_word=$2
8164 echo "$as_me:$LINENO: checking for $ac_word" >&5
8165 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8166 if test "${ac_cv_prog_STRIP+set}" = set; then
8167   echo $ECHO_N "(cached) $ECHO_C" >&6
8168 else
8169   if test -n "$STRIP"; then
8170   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8171 else
8172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8173 for as_dir in $PATH
8174 do
8175   IFS=$as_save_IFS
8176   test -z "$as_dir" && as_dir=.
8177   for ac_exec_ext in '' $ac_executable_extensions; do
8178   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8179     ac_cv_prog_STRIP="${ncn_progname}"
8180     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8181     break 2
8182   fi
8183 done
8184 done
8185
8186 fi
8187 fi
8188 STRIP=$ac_cv_prog_STRIP
8189 if test -n "$STRIP"; then
8190   echo "$as_me:$LINENO: result: $STRIP" >&5
8191 echo "${ECHO_T}$STRIP" >&6
8192 else
8193   echo "$as_me:$LINENO: result: no" >&5
8194 echo "${ECHO_T}no" >&6
8195 fi
8196
8197   fi
8198   test -n "$ac_cv_prog_STRIP" && break
8199 done
8200
8201 if test -z "$ac_cv_prog_STRIP" ; then
8202   STRIP=":"
8203 fi
8204
8205
8206
8207 if test -n "$WINDRES"; then
8208   ac_cv_prog_WINDRES=$WINDRES
8209 elif test -n "$ac_cv_prog_WINDRES"; then
8210   WINDRES=$ac_cv_prog_WINDRES
8211 fi
8212
8213 if test -n "$ac_cv_prog_WINDRES"; then
8214   for ncn_progname in windres; do
8215     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8216 set dummy ${ncn_progname}; ac_word=$2
8217 echo "$as_me:$LINENO: checking for $ac_word" >&5
8218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8219 if test "${ac_cv_prog_WINDRES+set}" = set; then
8220   echo $ECHO_N "(cached) $ECHO_C" >&6
8221 else
8222   if test -n "$WINDRES"; then
8223   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8224 else
8225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8226 for as_dir in $PATH
8227 do
8228   IFS=$as_save_IFS
8229   test -z "$as_dir" && as_dir=.
8230   for ac_exec_ext in '' $ac_executable_extensions; do
8231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8232     ac_cv_prog_WINDRES="${ncn_progname}"
8233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8234     break 2
8235   fi
8236 done
8237 done
8238
8239 fi
8240 fi
8241 WINDRES=$ac_cv_prog_WINDRES
8242 if test -n "$WINDRES"; then
8243   echo "$as_me:$LINENO: result: $WINDRES" >&5
8244 echo "${ECHO_T}$WINDRES" >&6
8245 else
8246   echo "$as_me:$LINENO: result: no" >&5
8247 echo "${ECHO_T}no" >&6
8248 fi
8249
8250   done
8251 fi
8252
8253 for ncn_progname in windres; do
8254   if test -n "$ncn_tool_prefix"; then
8255     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8256 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8257 echo "$as_me:$LINENO: checking for $ac_word" >&5
8258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8259 if test "${ac_cv_prog_WINDRES+set}" = set; then
8260   echo $ECHO_N "(cached) $ECHO_C" >&6
8261 else
8262   if test -n "$WINDRES"; then
8263   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8264 else
8265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8266 for as_dir in $PATH
8267 do
8268   IFS=$as_save_IFS
8269   test -z "$as_dir" && as_dir=.
8270   for ac_exec_ext in '' $ac_executable_extensions; do
8271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8272     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8274     break 2
8275   fi
8276 done
8277 done
8278
8279 fi
8280 fi
8281 WINDRES=$ac_cv_prog_WINDRES
8282 if test -n "$WINDRES"; then
8283   echo "$as_me:$LINENO: result: $WINDRES" >&5
8284 echo "${ECHO_T}$WINDRES" >&6
8285 else
8286   echo "$as_me:$LINENO: result: no" >&5
8287 echo "${ECHO_T}no" >&6
8288 fi
8289
8290   fi
8291   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8292     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8293 set dummy ${ncn_progname}; ac_word=$2
8294 echo "$as_me:$LINENO: checking for $ac_word" >&5
8295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8296 if test "${ac_cv_prog_WINDRES+set}" = set; then
8297   echo $ECHO_N "(cached) $ECHO_C" >&6
8298 else
8299   if test -n "$WINDRES"; then
8300   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8301 else
8302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8303 for as_dir in $PATH
8304 do
8305   IFS=$as_save_IFS
8306   test -z "$as_dir" && as_dir=.
8307   for ac_exec_ext in '' $ac_executable_extensions; do
8308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8309     ac_cv_prog_WINDRES="${ncn_progname}"
8310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8311     break 2
8312   fi
8313 done
8314 done
8315
8316 fi
8317 fi
8318 WINDRES=$ac_cv_prog_WINDRES
8319 if test -n "$WINDRES"; then
8320   echo "$as_me:$LINENO: result: $WINDRES" >&5
8321 echo "${ECHO_T}$WINDRES" >&6
8322 else
8323   echo "$as_me:$LINENO: result: no" >&5
8324 echo "${ECHO_T}no" >&6
8325 fi
8326
8327   fi
8328   test -n "$ac_cv_prog_WINDRES" && break
8329 done
8330
8331 if test -z "$ac_cv_prog_WINDRES" ; then
8332   set dummy windres
8333   if test $build = $host ; then
8334     WINDRES="$2"
8335   else
8336     WINDRES="${ncn_tool_prefix}$2"
8337   fi
8338 fi
8339
8340
8341
8342 if test -n "$WINDMC"; then
8343   ac_cv_prog_WINDMC=$WINDMC
8344 elif test -n "$ac_cv_prog_WINDMC"; then
8345   WINDMC=$ac_cv_prog_WINDMC
8346 fi
8347
8348 if test -n "$ac_cv_prog_WINDMC"; then
8349   for ncn_progname in windmc; do
8350     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8351 set dummy ${ncn_progname}; ac_word=$2
8352 echo "$as_me:$LINENO: checking for $ac_word" >&5
8353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8354 if test "${ac_cv_prog_WINDMC+set}" = set; then
8355   echo $ECHO_N "(cached) $ECHO_C" >&6
8356 else
8357   if test -n "$WINDMC"; then
8358   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8359 else
8360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8361 for as_dir in $PATH
8362 do
8363   IFS=$as_save_IFS
8364   test -z "$as_dir" && as_dir=.
8365   for ac_exec_ext in '' $ac_executable_extensions; do
8366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8367     ac_cv_prog_WINDMC="${ncn_progname}"
8368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8369     break 2
8370   fi
8371 done
8372 done
8373
8374 fi
8375 fi
8376 WINDMC=$ac_cv_prog_WINDMC
8377 if test -n "$WINDMC"; then
8378   echo "$as_me:$LINENO: result: $WINDMC" >&5
8379 echo "${ECHO_T}$WINDMC" >&6
8380 else
8381   echo "$as_me:$LINENO: result: no" >&5
8382 echo "${ECHO_T}no" >&6
8383 fi
8384
8385   done
8386 fi
8387
8388 for ncn_progname in windmc; do
8389   if test -n "$ncn_tool_prefix"; then
8390     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8391 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8392 echo "$as_me:$LINENO: checking for $ac_word" >&5
8393 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8394 if test "${ac_cv_prog_WINDMC+set}" = set; then
8395   echo $ECHO_N "(cached) $ECHO_C" >&6
8396 else
8397   if test -n "$WINDMC"; then
8398   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8399 else
8400 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8401 for as_dir in $PATH
8402 do
8403   IFS=$as_save_IFS
8404   test -z "$as_dir" && as_dir=.
8405   for ac_exec_ext in '' $ac_executable_extensions; do
8406   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8407     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8408     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8409     break 2
8410   fi
8411 done
8412 done
8413
8414 fi
8415 fi
8416 WINDMC=$ac_cv_prog_WINDMC
8417 if test -n "$WINDMC"; then
8418   echo "$as_me:$LINENO: result: $WINDMC" >&5
8419 echo "${ECHO_T}$WINDMC" >&6
8420 else
8421   echo "$as_me:$LINENO: result: no" >&5
8422 echo "${ECHO_T}no" >&6
8423 fi
8424
8425   fi
8426   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8427     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8428 set dummy ${ncn_progname}; ac_word=$2
8429 echo "$as_me:$LINENO: checking for $ac_word" >&5
8430 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8431 if test "${ac_cv_prog_WINDMC+set}" = set; then
8432   echo $ECHO_N "(cached) $ECHO_C" >&6
8433 else
8434   if test -n "$WINDMC"; then
8435   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8436 else
8437 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8438 for as_dir in $PATH
8439 do
8440   IFS=$as_save_IFS
8441   test -z "$as_dir" && as_dir=.
8442   for ac_exec_ext in '' $ac_executable_extensions; do
8443   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8444     ac_cv_prog_WINDMC="${ncn_progname}"
8445     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8446     break 2
8447   fi
8448 done
8449 done
8450
8451 fi
8452 fi
8453 WINDMC=$ac_cv_prog_WINDMC
8454 if test -n "$WINDMC"; then
8455   echo "$as_me:$LINENO: result: $WINDMC" >&5
8456 echo "${ECHO_T}$WINDMC" >&6
8457 else
8458   echo "$as_me:$LINENO: result: no" >&5
8459 echo "${ECHO_T}no" >&6
8460 fi
8461
8462   fi
8463   test -n "$ac_cv_prog_WINDMC" && break
8464 done
8465
8466 if test -z "$ac_cv_prog_WINDMC" ; then
8467   set dummy windmc
8468   if test $build = $host ; then
8469     WINDMC="$2"
8470   else
8471     WINDMC="${ncn_tool_prefix}$2"
8472   fi
8473 fi
8474
8475
8476
8477 if test -n "$OBJCOPY"; then
8478   ac_cv_prog_OBJCOPY=$OBJCOPY
8479 elif test -n "$ac_cv_prog_OBJCOPY"; then
8480   OBJCOPY=$ac_cv_prog_OBJCOPY
8481 fi
8482
8483 if test -n "$ac_cv_prog_OBJCOPY"; then
8484   for ncn_progname in objcopy; do
8485     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8486 set dummy ${ncn_progname}; ac_word=$2
8487 echo "$as_me:$LINENO: checking for $ac_word" >&5
8488 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8489 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8490   echo $ECHO_N "(cached) $ECHO_C" >&6
8491 else
8492   if test -n "$OBJCOPY"; then
8493   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8494 else
8495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8496 for as_dir in $PATH
8497 do
8498   IFS=$as_save_IFS
8499   test -z "$as_dir" && as_dir=.
8500   for ac_exec_ext in '' $ac_executable_extensions; do
8501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8502     ac_cv_prog_OBJCOPY="${ncn_progname}"
8503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8504     break 2
8505   fi
8506 done
8507 done
8508
8509 fi
8510 fi
8511 OBJCOPY=$ac_cv_prog_OBJCOPY
8512 if test -n "$OBJCOPY"; then
8513   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8514 echo "${ECHO_T}$OBJCOPY" >&6
8515 else
8516   echo "$as_me:$LINENO: result: no" >&5
8517 echo "${ECHO_T}no" >&6
8518 fi
8519
8520   done
8521 fi
8522
8523 for ncn_progname in objcopy; do
8524   if test -n "$ncn_tool_prefix"; then
8525     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8526 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8527 echo "$as_me:$LINENO: checking for $ac_word" >&5
8528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8529 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8530   echo $ECHO_N "(cached) $ECHO_C" >&6
8531 else
8532   if test -n "$OBJCOPY"; then
8533   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8534 else
8535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8536 for as_dir in $PATH
8537 do
8538   IFS=$as_save_IFS
8539   test -z "$as_dir" && as_dir=.
8540   for ac_exec_ext in '' $ac_executable_extensions; do
8541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8542     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8544     break 2
8545   fi
8546 done
8547 done
8548
8549 fi
8550 fi
8551 OBJCOPY=$ac_cv_prog_OBJCOPY
8552 if test -n "$OBJCOPY"; then
8553   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8554 echo "${ECHO_T}$OBJCOPY" >&6
8555 else
8556   echo "$as_me:$LINENO: result: no" >&5
8557 echo "${ECHO_T}no" >&6
8558 fi
8559
8560   fi
8561   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8562     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8563 set dummy ${ncn_progname}; ac_word=$2
8564 echo "$as_me:$LINENO: checking for $ac_word" >&5
8565 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8566 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8567   echo $ECHO_N "(cached) $ECHO_C" >&6
8568 else
8569   if test -n "$OBJCOPY"; then
8570   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8571 else
8572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8573 for as_dir in $PATH
8574 do
8575   IFS=$as_save_IFS
8576   test -z "$as_dir" && as_dir=.
8577   for ac_exec_ext in '' $ac_executable_extensions; do
8578   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8579     ac_cv_prog_OBJCOPY="${ncn_progname}"
8580     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8581     break 2
8582   fi
8583 done
8584 done
8585
8586 fi
8587 fi
8588 OBJCOPY=$ac_cv_prog_OBJCOPY
8589 if test -n "$OBJCOPY"; then
8590   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8591 echo "${ECHO_T}$OBJCOPY" >&6
8592 else
8593   echo "$as_me:$LINENO: result: no" >&5
8594 echo "${ECHO_T}no" >&6
8595 fi
8596
8597   fi
8598   test -n "$ac_cv_prog_OBJCOPY" && break
8599 done
8600
8601 if test -z "$ac_cv_prog_OBJCOPY" ; then
8602   set dummy objcopy
8603   if test $build = $host ; then
8604     OBJCOPY="$2"
8605   else
8606     OBJCOPY="${ncn_tool_prefix}$2"
8607   fi
8608 fi
8609
8610
8611
8612 if test -n "$OBJDUMP"; then
8613   ac_cv_prog_OBJDUMP=$OBJDUMP
8614 elif test -n "$ac_cv_prog_OBJDUMP"; then
8615   OBJDUMP=$ac_cv_prog_OBJDUMP
8616 fi
8617
8618 if test -n "$ac_cv_prog_OBJDUMP"; then
8619   for ncn_progname in objdump; do
8620     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8621 set dummy ${ncn_progname}; ac_word=$2
8622 echo "$as_me:$LINENO: checking for $ac_word" >&5
8623 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8624 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8625   echo $ECHO_N "(cached) $ECHO_C" >&6
8626 else
8627   if test -n "$OBJDUMP"; then
8628   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8629 else
8630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8631 for as_dir in $PATH
8632 do
8633   IFS=$as_save_IFS
8634   test -z "$as_dir" && as_dir=.
8635   for ac_exec_ext in '' $ac_executable_extensions; do
8636   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8637     ac_cv_prog_OBJDUMP="${ncn_progname}"
8638     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8639     break 2
8640   fi
8641 done
8642 done
8643
8644 fi
8645 fi
8646 OBJDUMP=$ac_cv_prog_OBJDUMP
8647 if test -n "$OBJDUMP"; then
8648   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8649 echo "${ECHO_T}$OBJDUMP" >&6
8650 else
8651   echo "$as_me:$LINENO: result: no" >&5
8652 echo "${ECHO_T}no" >&6
8653 fi
8654
8655   done
8656 fi
8657
8658 for ncn_progname in objdump; do
8659   if test -n "$ncn_tool_prefix"; then
8660     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8661 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8662 echo "$as_me:$LINENO: checking for $ac_word" >&5
8663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8664 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8665   echo $ECHO_N "(cached) $ECHO_C" >&6
8666 else
8667   if test -n "$OBJDUMP"; then
8668   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8669 else
8670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8671 for as_dir in $PATH
8672 do
8673   IFS=$as_save_IFS
8674   test -z "$as_dir" && as_dir=.
8675   for ac_exec_ext in '' $ac_executable_extensions; do
8676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8677     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8679     break 2
8680   fi
8681 done
8682 done
8683
8684 fi
8685 fi
8686 OBJDUMP=$ac_cv_prog_OBJDUMP
8687 if test -n "$OBJDUMP"; then
8688   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8689 echo "${ECHO_T}$OBJDUMP" >&6
8690 else
8691   echo "$as_me:$LINENO: result: no" >&5
8692 echo "${ECHO_T}no" >&6
8693 fi
8694
8695   fi
8696   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8697     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8698 set dummy ${ncn_progname}; ac_word=$2
8699 echo "$as_me:$LINENO: checking for $ac_word" >&5
8700 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8701 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8702   echo $ECHO_N "(cached) $ECHO_C" >&6
8703 else
8704   if test -n "$OBJDUMP"; then
8705   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8706 else
8707 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8708 for as_dir in $PATH
8709 do
8710   IFS=$as_save_IFS
8711   test -z "$as_dir" && as_dir=.
8712   for ac_exec_ext in '' $ac_executable_extensions; do
8713   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8714     ac_cv_prog_OBJDUMP="${ncn_progname}"
8715     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8716     break 2
8717   fi
8718 done
8719 done
8720
8721 fi
8722 fi
8723 OBJDUMP=$ac_cv_prog_OBJDUMP
8724 if test -n "$OBJDUMP"; then
8725   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8726 echo "${ECHO_T}$OBJDUMP" >&6
8727 else
8728   echo "$as_me:$LINENO: result: no" >&5
8729 echo "${ECHO_T}no" >&6
8730 fi
8731
8732   fi
8733   test -n "$ac_cv_prog_OBJDUMP" && break
8734 done
8735
8736 if test -z "$ac_cv_prog_OBJDUMP" ; then
8737   set dummy objdump
8738   if test $build = $host ; then
8739     OBJDUMP="$2"
8740   else
8741     OBJDUMP="${ncn_tool_prefix}$2"
8742   fi
8743 fi
8744
8745
8746
8747
8748
8749
8750 # Target tools.
8751
8752 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8753 if test "${with_build_time_tools+set}" = set; then
8754   withval="$with_build_time_tools"
8755   case x"$withval" in
8756      x/*) ;;
8757      *)
8758        with_build_time_tools=
8759        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8760 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8761        ;;
8762    esac
8763 else
8764   with_build_time_tools=
8765 fi;
8766
8767
8768
8769 if test -n "$CC_FOR_TARGET"; then
8770   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8771 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8772   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8773 fi
8774
8775 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8776   for ncn_progname in cc gcc; do
8777     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8778 set dummy ${ncn_progname}; ac_word=$2
8779 echo "$as_me:$LINENO: checking for $ac_word" >&5
8780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8781 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8782   echo $ECHO_N "(cached) $ECHO_C" >&6
8783 else
8784   if test -n "$CC_FOR_TARGET"; then
8785   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8786 else
8787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8788 for as_dir in $PATH
8789 do
8790   IFS=$as_save_IFS
8791   test -z "$as_dir" && as_dir=.
8792   for ac_exec_ext in '' $ac_executable_extensions; do
8793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8794     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8796     break 2
8797   fi
8798 done
8799 done
8800
8801 fi
8802 fi
8803 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8804 if test -n "$CC_FOR_TARGET"; then
8805   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8806 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8807 else
8808   echo "$as_me:$LINENO: result: no" >&5
8809 echo "${ECHO_T}no" >&6
8810 fi
8811
8812   done
8813 fi
8814
8815 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8816   for ncn_progname in cc gcc; do
8817     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8818 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8819     if test -x $with_build_time_tools/${ncn_progname}; then
8820       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8821       echo "$as_me:$LINENO: result: yes" >&5
8822 echo "${ECHO_T}yes" >&6
8823       break
8824     else
8825       echo "$as_me:$LINENO: result: no" >&5
8826 echo "${ECHO_T}no" >&6
8827     fi
8828   done
8829 fi
8830
8831 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8832   for ncn_progname in cc gcc; do
8833     if test -n "$ncn_target_tool_prefix"; then
8834       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8835 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8836 echo "$as_me:$LINENO: checking for $ac_word" >&5
8837 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8838 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8839   echo $ECHO_N "(cached) $ECHO_C" >&6
8840 else
8841   if test -n "$CC_FOR_TARGET"; then
8842   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8843 else
8844 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8845 for as_dir in $PATH
8846 do
8847   IFS=$as_save_IFS
8848   test -z "$as_dir" && as_dir=.
8849   for ac_exec_ext in '' $ac_executable_extensions; do
8850   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8851     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8852     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8853     break 2
8854   fi
8855 done
8856 done
8857
8858 fi
8859 fi
8860 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8861 if test -n "$CC_FOR_TARGET"; then
8862   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8863 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8864 else
8865   echo "$as_me:$LINENO: result: no" >&5
8866 echo "${ECHO_T}no" >&6
8867 fi
8868
8869     fi
8870     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8871       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8872 set dummy ${ncn_progname}; ac_word=$2
8873 echo "$as_me:$LINENO: checking for $ac_word" >&5
8874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8875 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8876   echo $ECHO_N "(cached) $ECHO_C" >&6
8877 else
8878   if test -n "$CC_FOR_TARGET"; then
8879   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8880 else
8881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8882 for as_dir in $PATH
8883 do
8884   IFS=$as_save_IFS
8885   test -z "$as_dir" && as_dir=.
8886   for ac_exec_ext in '' $ac_executable_extensions; do
8887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8888     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8890     break 2
8891   fi
8892 done
8893 done
8894
8895 fi
8896 fi
8897 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8898 if test -n "$CC_FOR_TARGET"; then
8899   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8900 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8901 else
8902   echo "$as_me:$LINENO: result: no" >&5
8903 echo "${ECHO_T}no" >&6
8904 fi
8905
8906     fi
8907     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8908   done
8909 fi
8910
8911 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8912   set dummy cc gcc
8913   if test $build = $target ; then
8914     CC_FOR_TARGET="$2"
8915   else
8916     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8917   fi
8918 else
8919   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8920 fi
8921
8922
8923
8924 if test -n "$CXX_FOR_TARGET"; then
8925   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8926 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8927   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8928 fi
8929
8930 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8931   for ncn_progname in c++ g++ cxx gxx; do
8932     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8933 set dummy ${ncn_progname}; ac_word=$2
8934 echo "$as_me:$LINENO: checking for $ac_word" >&5
8935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8936 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8937   echo $ECHO_N "(cached) $ECHO_C" >&6
8938 else
8939   if test -n "$CXX_FOR_TARGET"; then
8940   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8941 else
8942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8943 for as_dir in $PATH
8944 do
8945   IFS=$as_save_IFS
8946   test -z "$as_dir" && as_dir=.
8947   for ac_exec_ext in '' $ac_executable_extensions; do
8948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8949     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8951     break 2
8952   fi
8953 done
8954 done
8955
8956 fi
8957 fi
8958 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8959 if test -n "$CXX_FOR_TARGET"; then
8960   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8961 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8962 else
8963   echo "$as_me:$LINENO: result: no" >&5
8964 echo "${ECHO_T}no" >&6
8965 fi
8966
8967   done
8968 fi
8969
8970 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8971   for ncn_progname in c++ g++ cxx gxx; do
8972     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8973 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8974     if test -x $with_build_time_tools/${ncn_progname}; then
8975       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8976       echo "$as_me:$LINENO: result: yes" >&5
8977 echo "${ECHO_T}yes" >&6
8978       break
8979     else
8980       echo "$as_me:$LINENO: result: no" >&5
8981 echo "${ECHO_T}no" >&6
8982     fi
8983   done
8984 fi
8985
8986 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8987   for ncn_progname in c++ g++ cxx gxx; do
8988     if test -n "$ncn_target_tool_prefix"; then
8989       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8990 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8991 echo "$as_me:$LINENO: checking for $ac_word" >&5
8992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8993 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8994   echo $ECHO_N "(cached) $ECHO_C" >&6
8995 else
8996   if test -n "$CXX_FOR_TARGET"; then
8997   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8998 else
8999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9000 for as_dir in $PATH
9001 do
9002   IFS=$as_save_IFS
9003   test -z "$as_dir" && as_dir=.
9004   for ac_exec_ext in '' $ac_executable_extensions; do
9005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9006     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9008     break 2
9009   fi
9010 done
9011 done
9012
9013 fi
9014 fi
9015 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9016 if test -n "$CXX_FOR_TARGET"; then
9017   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9018 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9019 else
9020   echo "$as_me:$LINENO: result: no" >&5
9021 echo "${ECHO_T}no" >&6
9022 fi
9023
9024     fi
9025     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
9026       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9027 set dummy ${ncn_progname}; ac_word=$2
9028 echo "$as_me:$LINENO: checking for $ac_word" >&5
9029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9030 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9031   echo $ECHO_N "(cached) $ECHO_C" >&6
9032 else
9033   if test -n "$CXX_FOR_TARGET"; then
9034   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9035 else
9036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9037 for as_dir in $PATH
9038 do
9039   IFS=$as_save_IFS
9040   test -z "$as_dir" && as_dir=.
9041   for ac_exec_ext in '' $ac_executable_extensions; do
9042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9043     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
9044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9045     break 2
9046   fi
9047 done
9048 done
9049
9050 fi
9051 fi
9052 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9053 if test -n "$CXX_FOR_TARGET"; then
9054   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9055 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9056 else
9057   echo "$as_me:$LINENO: result: no" >&5
9058 echo "${ECHO_T}no" >&6
9059 fi
9060
9061     fi
9062     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
9063   done
9064 fi
9065
9066 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
9067   set dummy c++ g++ cxx gxx
9068   if test $build = $target ; then
9069     CXX_FOR_TARGET="$2"
9070   else
9071     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
9072   fi
9073 else
9074   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
9075 fi
9076
9077
9078
9079 if test -n "$GCC_FOR_TARGET"; then
9080   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
9081 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9082   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9083 fi
9084
9085 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9086   for ncn_progname in gcc; do
9087     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9088 set dummy ${ncn_progname}; ac_word=$2
9089 echo "$as_me:$LINENO: checking for $ac_word" >&5
9090 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9091 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9092   echo $ECHO_N "(cached) $ECHO_C" >&6
9093 else
9094   if test -n "$GCC_FOR_TARGET"; then
9095   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9096 else
9097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9098 for as_dir in $PATH
9099 do
9100   IFS=$as_save_IFS
9101   test -z "$as_dir" && as_dir=.
9102   for ac_exec_ext in '' $ac_executable_extensions; do
9103   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9104     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9105     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9106     break 2
9107   fi
9108 done
9109 done
9110
9111 fi
9112 fi
9113 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9114 if test -n "$GCC_FOR_TARGET"; then
9115   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9116 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9117 else
9118   echo "$as_me:$LINENO: result: no" >&5
9119 echo "${ECHO_T}no" >&6
9120 fi
9121
9122   done
9123 fi
9124
9125 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9126   for ncn_progname in gcc; do
9127     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9128 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9129     if test -x $with_build_time_tools/${ncn_progname}; then
9130       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9131       echo "$as_me:$LINENO: result: yes" >&5
9132 echo "${ECHO_T}yes" >&6
9133       break
9134     else
9135       echo "$as_me:$LINENO: result: no" >&5
9136 echo "${ECHO_T}no" >&6
9137     fi
9138   done
9139 fi
9140
9141 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9142   for ncn_progname in gcc; do
9143     if test -n "$ncn_target_tool_prefix"; then
9144       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9145 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9146 echo "$as_me:$LINENO: checking for $ac_word" >&5
9147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9148 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9149   echo $ECHO_N "(cached) $ECHO_C" >&6
9150 else
9151   if test -n "$GCC_FOR_TARGET"; then
9152   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9153 else
9154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9155 for as_dir in $PATH
9156 do
9157   IFS=$as_save_IFS
9158   test -z "$as_dir" && as_dir=.
9159   for ac_exec_ext in '' $ac_executable_extensions; do
9160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9161     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9163     break 2
9164   fi
9165 done
9166 done
9167
9168 fi
9169 fi
9170 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9171 if test -n "$GCC_FOR_TARGET"; then
9172   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9173 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9174 else
9175   echo "$as_me:$LINENO: result: no" >&5
9176 echo "${ECHO_T}no" >&6
9177 fi
9178
9179     fi
9180     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9181       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9182 set dummy ${ncn_progname}; ac_word=$2
9183 echo "$as_me:$LINENO: checking for $ac_word" >&5
9184 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9185 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9186   echo $ECHO_N "(cached) $ECHO_C" >&6
9187 else
9188   if test -n "$GCC_FOR_TARGET"; then
9189   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9190 else
9191 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9192 for as_dir in $PATH
9193 do
9194   IFS=$as_save_IFS
9195   test -z "$as_dir" && as_dir=.
9196   for ac_exec_ext in '' $ac_executable_extensions; do
9197   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9198     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9199     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9200     break 2
9201   fi
9202 done
9203 done
9204
9205 fi
9206 fi
9207 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9208 if test -n "$GCC_FOR_TARGET"; then
9209   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9210 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9211 else
9212   echo "$as_me:$LINENO: result: no" >&5
9213 echo "${ECHO_T}no" >&6
9214 fi
9215
9216     fi
9217     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9218   done
9219 fi
9220
9221 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9222   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9223 else
9224   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9225 fi
9226
9227
9228
9229 if test -n "$GCJ_FOR_TARGET"; then
9230   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9231 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9232   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9233 fi
9234
9235 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9236   for ncn_progname in gcj; do
9237     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9238 set dummy ${ncn_progname}; ac_word=$2
9239 echo "$as_me:$LINENO: checking for $ac_word" >&5
9240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9241 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9242   echo $ECHO_N "(cached) $ECHO_C" >&6
9243 else
9244   if test -n "$GCJ_FOR_TARGET"; then
9245   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9246 else
9247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9248 for as_dir in $PATH
9249 do
9250   IFS=$as_save_IFS
9251   test -z "$as_dir" && as_dir=.
9252   for ac_exec_ext in '' $ac_executable_extensions; do
9253   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9254     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9255     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9256     break 2
9257   fi
9258 done
9259 done
9260
9261 fi
9262 fi
9263 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9264 if test -n "$GCJ_FOR_TARGET"; then
9265   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9266 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9267 else
9268   echo "$as_me:$LINENO: result: no" >&5
9269 echo "${ECHO_T}no" >&6
9270 fi
9271
9272   done
9273 fi
9274
9275 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9276   for ncn_progname in gcj; do
9277     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9278 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9279     if test -x $with_build_time_tools/${ncn_progname}; then
9280       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9281       echo "$as_me:$LINENO: result: yes" >&5
9282 echo "${ECHO_T}yes" >&6
9283       break
9284     else
9285       echo "$as_me:$LINENO: result: no" >&5
9286 echo "${ECHO_T}no" >&6
9287     fi
9288   done
9289 fi
9290
9291 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9292   for ncn_progname in gcj; do
9293     if test -n "$ncn_target_tool_prefix"; then
9294       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9295 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9296 echo "$as_me:$LINENO: checking for $ac_word" >&5
9297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9298 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9299   echo $ECHO_N "(cached) $ECHO_C" >&6
9300 else
9301   if test -n "$GCJ_FOR_TARGET"; then
9302   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9303 else
9304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9305 for as_dir in $PATH
9306 do
9307   IFS=$as_save_IFS
9308   test -z "$as_dir" && as_dir=.
9309   for ac_exec_ext in '' $ac_executable_extensions; do
9310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9311     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9313     break 2
9314   fi
9315 done
9316 done
9317
9318 fi
9319 fi
9320 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9321 if test -n "$GCJ_FOR_TARGET"; then
9322   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9323 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9324 else
9325   echo "$as_me:$LINENO: result: no" >&5
9326 echo "${ECHO_T}no" >&6
9327 fi
9328
9329     fi
9330     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9331       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9332 set dummy ${ncn_progname}; ac_word=$2
9333 echo "$as_me:$LINENO: checking for $ac_word" >&5
9334 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9335 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9336   echo $ECHO_N "(cached) $ECHO_C" >&6
9337 else
9338   if test -n "$GCJ_FOR_TARGET"; then
9339   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9340 else
9341 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9342 for as_dir in $PATH
9343 do
9344   IFS=$as_save_IFS
9345   test -z "$as_dir" && as_dir=.
9346   for ac_exec_ext in '' $ac_executable_extensions; do
9347   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9348     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9349     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9350     break 2
9351   fi
9352 done
9353 done
9354
9355 fi
9356 fi
9357 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9358 if test -n "$GCJ_FOR_TARGET"; then
9359   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9360 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9361 else
9362   echo "$as_me:$LINENO: result: no" >&5
9363 echo "${ECHO_T}no" >&6
9364 fi
9365
9366     fi
9367     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9368   done
9369 fi
9370
9371 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9372   set dummy gcj
9373   if test $build = $target ; then
9374     GCJ_FOR_TARGET="$2"
9375   else
9376     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9377   fi
9378 else
9379   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9380 fi
9381
9382
9383
9384 if test -n "$GFORTRAN_FOR_TARGET"; then
9385   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9386 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9387   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9388 fi
9389
9390 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9391   for ncn_progname in gfortran; do
9392     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9393 set dummy ${ncn_progname}; ac_word=$2
9394 echo "$as_me:$LINENO: checking for $ac_word" >&5
9395 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9396 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9397   echo $ECHO_N "(cached) $ECHO_C" >&6
9398 else
9399   if test -n "$GFORTRAN_FOR_TARGET"; then
9400   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9401 else
9402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9403 for as_dir in $PATH
9404 do
9405   IFS=$as_save_IFS
9406   test -z "$as_dir" && as_dir=.
9407   for ac_exec_ext in '' $ac_executable_extensions; do
9408   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9409     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9410     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9411     break 2
9412   fi
9413 done
9414 done
9415
9416 fi
9417 fi
9418 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9419 if test -n "$GFORTRAN_FOR_TARGET"; then
9420   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9421 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9422 else
9423   echo "$as_me:$LINENO: result: no" >&5
9424 echo "${ECHO_T}no" >&6
9425 fi
9426
9427   done
9428 fi
9429
9430 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9431   for ncn_progname in gfortran; do
9432     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9433 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9434     if test -x $with_build_time_tools/${ncn_progname}; then
9435       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9436       echo "$as_me:$LINENO: result: yes" >&5
9437 echo "${ECHO_T}yes" >&6
9438       break
9439     else
9440       echo "$as_me:$LINENO: result: no" >&5
9441 echo "${ECHO_T}no" >&6
9442     fi
9443   done
9444 fi
9445
9446 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9447   for ncn_progname in gfortran; do
9448     if test -n "$ncn_target_tool_prefix"; then
9449       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9450 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9451 echo "$as_me:$LINENO: checking for $ac_word" >&5
9452 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9453 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9454   echo $ECHO_N "(cached) $ECHO_C" >&6
9455 else
9456   if test -n "$GFORTRAN_FOR_TARGET"; then
9457   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9458 else
9459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9460 for as_dir in $PATH
9461 do
9462   IFS=$as_save_IFS
9463   test -z "$as_dir" && as_dir=.
9464   for ac_exec_ext in '' $ac_executable_extensions; do
9465   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9466     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9467     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9468     break 2
9469   fi
9470 done
9471 done
9472
9473 fi
9474 fi
9475 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9476 if test -n "$GFORTRAN_FOR_TARGET"; then
9477   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9478 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9479 else
9480   echo "$as_me:$LINENO: result: no" >&5
9481 echo "${ECHO_T}no" >&6
9482 fi
9483
9484     fi
9485     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9486       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9487 set dummy ${ncn_progname}; ac_word=$2
9488 echo "$as_me:$LINENO: checking for $ac_word" >&5
9489 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9490 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9491   echo $ECHO_N "(cached) $ECHO_C" >&6
9492 else
9493   if test -n "$GFORTRAN_FOR_TARGET"; then
9494   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9495 else
9496 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9497 for as_dir in $PATH
9498 do
9499   IFS=$as_save_IFS
9500   test -z "$as_dir" && as_dir=.
9501   for ac_exec_ext in '' $ac_executable_extensions; do
9502   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9503     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9504     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9505     break 2
9506   fi
9507 done
9508 done
9509
9510 fi
9511 fi
9512 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9513 if test -n "$GFORTRAN_FOR_TARGET"; then
9514   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9515 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9516 else
9517   echo "$as_me:$LINENO: result: no" >&5
9518 echo "${ECHO_T}no" >&6
9519 fi
9520
9521     fi
9522     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9523   done
9524 fi
9525
9526 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9527   set dummy gfortran
9528   if test $build = $target ; then
9529     GFORTRAN_FOR_TARGET="$2"
9530   else
9531     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9532   fi
9533 else
9534   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9535 fi
9536
9537
9538
9539 cat > conftest.c << \EOF
9540 #ifdef __GNUC__
9541   gcc_yay;
9542 #endif
9543 EOF
9544 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9545   have_gcc_for_target=yes
9546 else
9547   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9548   have_gcc_for_target=no
9549 fi
9550 rm conftest.c
9551
9552
9553
9554
9555 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9556   if test -n "$with_build_time_tools"; then
9557     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9558 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9559     if test -x $with_build_time_tools/ar; then
9560       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9561       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9562       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9563 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9564     else
9565       echo "$as_me:$LINENO: result: no" >&5
9566 echo "${ECHO_T}no" >&6
9567     fi
9568   elif test $build != $host && test $have_gcc_for_target = yes; then
9569     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9570     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9571     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9572   fi
9573 fi
9574 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9575   # Extract the first word of "ar", so it can be a program name with args.
9576 set dummy ar; ac_word=$2
9577 echo "$as_me:$LINENO: checking for $ac_word" >&5
9578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9579 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9580   echo $ECHO_N "(cached) $ECHO_C" >&6
9581 else
9582   case $AR_FOR_TARGET in
9583   [\\/]* | ?:[\\/]*)
9584   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9585   ;;
9586   *)
9587   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9588 for as_dir in $gcc_cv_tool_dirs
9589 do
9590   IFS=$as_save_IFS
9591   test -z "$as_dir" && as_dir=.
9592   for ac_exec_ext in '' $ac_executable_extensions; do
9593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9594     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9596     break 2
9597   fi
9598 done
9599 done
9600
9601   ;;
9602 esac
9603 fi
9604 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9605
9606 if test -n "$AR_FOR_TARGET"; then
9607   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9608 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9609 else
9610   echo "$as_me:$LINENO: result: no" >&5
9611 echo "${ECHO_T}no" >&6
9612 fi
9613
9614 fi
9615 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9616
9617
9618 if test -n "$AR_FOR_TARGET"; then
9619   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9620 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9621   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9622 fi
9623
9624 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9625   for ncn_progname in ar; do
9626     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9627 set dummy ${ncn_progname}; ac_word=$2
9628 echo "$as_me:$LINENO: checking for $ac_word" >&5
9629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9630 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9631   echo $ECHO_N "(cached) $ECHO_C" >&6
9632 else
9633   if test -n "$AR_FOR_TARGET"; then
9634   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9635 else
9636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9637 for as_dir in $PATH
9638 do
9639   IFS=$as_save_IFS
9640   test -z "$as_dir" && as_dir=.
9641   for ac_exec_ext in '' $ac_executable_extensions; do
9642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9643     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9645     break 2
9646   fi
9647 done
9648 done
9649
9650 fi
9651 fi
9652 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9653 if test -n "$AR_FOR_TARGET"; then
9654   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9655 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9656 else
9657   echo "$as_me:$LINENO: result: no" >&5
9658 echo "${ECHO_T}no" >&6
9659 fi
9660
9661   done
9662 fi
9663
9664 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9665   for ncn_progname in ar; do
9666     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9667 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9668     if test -x $with_build_time_tools/${ncn_progname}; then
9669       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9670       echo "$as_me:$LINENO: result: yes" >&5
9671 echo "${ECHO_T}yes" >&6
9672       break
9673     else
9674       echo "$as_me:$LINENO: result: no" >&5
9675 echo "${ECHO_T}no" >&6
9676     fi
9677   done
9678 fi
9679
9680 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9681   for ncn_progname in ar; do
9682     if test -n "$ncn_target_tool_prefix"; then
9683       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9684 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9685 echo "$as_me:$LINENO: checking for $ac_word" >&5
9686 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9687 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9688   echo $ECHO_N "(cached) $ECHO_C" >&6
9689 else
9690   if test -n "$AR_FOR_TARGET"; then
9691   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9692 else
9693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9694 for as_dir in $PATH
9695 do
9696   IFS=$as_save_IFS
9697   test -z "$as_dir" && as_dir=.
9698   for ac_exec_ext in '' $ac_executable_extensions; do
9699   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9700     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9701     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9702     break 2
9703   fi
9704 done
9705 done
9706
9707 fi
9708 fi
9709 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9710 if test -n "$AR_FOR_TARGET"; then
9711   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9712 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9713 else
9714   echo "$as_me:$LINENO: result: no" >&5
9715 echo "${ECHO_T}no" >&6
9716 fi
9717
9718     fi
9719     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9720       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9721 set dummy ${ncn_progname}; ac_word=$2
9722 echo "$as_me:$LINENO: checking for $ac_word" >&5
9723 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9724 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9725   echo $ECHO_N "(cached) $ECHO_C" >&6
9726 else
9727   if test -n "$AR_FOR_TARGET"; then
9728   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9729 else
9730 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9731 for as_dir in $PATH
9732 do
9733   IFS=$as_save_IFS
9734   test -z "$as_dir" && as_dir=.
9735   for ac_exec_ext in '' $ac_executable_extensions; do
9736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9737     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9739     break 2
9740   fi
9741 done
9742 done
9743
9744 fi
9745 fi
9746 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9747 if test -n "$AR_FOR_TARGET"; then
9748   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9749 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9750 else
9751   echo "$as_me:$LINENO: result: no" >&5
9752 echo "${ECHO_T}no" >&6
9753 fi
9754
9755     fi
9756     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9757   done
9758 fi
9759
9760 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9761   set dummy ar
9762   if test $build = $target ; then
9763     AR_FOR_TARGET="$2"
9764   else
9765     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9766   fi
9767 else
9768   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9769 fi
9770
9771 else
9772   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9773 fi
9774
9775
9776
9777
9778 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9779   if test -n "$with_build_time_tools"; then
9780     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9781 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9782     if test -x $with_build_time_tools/as; then
9783       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9784       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9785       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9786 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9787     else
9788       echo "$as_me:$LINENO: result: no" >&5
9789 echo "${ECHO_T}no" >&6
9790     fi
9791   elif test $build != $host && test $have_gcc_for_target = yes; then
9792     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9793     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9794     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9795   fi
9796 fi
9797 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9798   # Extract the first word of "as", so it can be a program name with args.
9799 set dummy as; ac_word=$2
9800 echo "$as_me:$LINENO: checking for $ac_word" >&5
9801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9802 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9803   echo $ECHO_N "(cached) $ECHO_C" >&6
9804 else
9805   case $AS_FOR_TARGET in
9806   [\\/]* | ?:[\\/]*)
9807   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9808   ;;
9809   *)
9810   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9811 for as_dir in $gcc_cv_tool_dirs
9812 do
9813   IFS=$as_save_IFS
9814   test -z "$as_dir" && as_dir=.
9815   for ac_exec_ext in '' $ac_executable_extensions; do
9816   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9817     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9818     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9819     break 2
9820   fi
9821 done
9822 done
9823
9824   ;;
9825 esac
9826 fi
9827 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9828
9829 if test -n "$AS_FOR_TARGET"; then
9830   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9831 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9832 else
9833   echo "$as_me:$LINENO: result: no" >&5
9834 echo "${ECHO_T}no" >&6
9835 fi
9836
9837 fi
9838 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9839
9840
9841 if test -n "$AS_FOR_TARGET"; then
9842   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9843 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9844   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9845 fi
9846
9847 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9848   for ncn_progname in as; do
9849     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9850 set dummy ${ncn_progname}; ac_word=$2
9851 echo "$as_me:$LINENO: checking for $ac_word" >&5
9852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9853 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9854   echo $ECHO_N "(cached) $ECHO_C" >&6
9855 else
9856   if test -n "$AS_FOR_TARGET"; then
9857   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9858 else
9859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9860 for as_dir in $PATH
9861 do
9862   IFS=$as_save_IFS
9863   test -z "$as_dir" && as_dir=.
9864   for ac_exec_ext in '' $ac_executable_extensions; do
9865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9866     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9868     break 2
9869   fi
9870 done
9871 done
9872
9873 fi
9874 fi
9875 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9876 if test -n "$AS_FOR_TARGET"; then
9877   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9878 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9879 else
9880   echo "$as_me:$LINENO: result: no" >&5
9881 echo "${ECHO_T}no" >&6
9882 fi
9883
9884   done
9885 fi
9886
9887 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9888   for ncn_progname in as; do
9889     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9890 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9891     if test -x $with_build_time_tools/${ncn_progname}; then
9892       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9893       echo "$as_me:$LINENO: result: yes" >&5
9894 echo "${ECHO_T}yes" >&6
9895       break
9896     else
9897       echo "$as_me:$LINENO: result: no" >&5
9898 echo "${ECHO_T}no" >&6
9899     fi
9900   done
9901 fi
9902
9903 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9904   for ncn_progname in as; do
9905     if test -n "$ncn_target_tool_prefix"; then
9906       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9907 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9908 echo "$as_me:$LINENO: checking for $ac_word" >&5
9909 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9910 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9911   echo $ECHO_N "(cached) $ECHO_C" >&6
9912 else
9913   if test -n "$AS_FOR_TARGET"; then
9914   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9915 else
9916 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9917 for as_dir in $PATH
9918 do
9919   IFS=$as_save_IFS
9920   test -z "$as_dir" && as_dir=.
9921   for ac_exec_ext in '' $ac_executable_extensions; do
9922   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9923     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9924     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9925     break 2
9926   fi
9927 done
9928 done
9929
9930 fi
9931 fi
9932 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9933 if test -n "$AS_FOR_TARGET"; then
9934   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9935 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9936 else
9937   echo "$as_me:$LINENO: result: no" >&5
9938 echo "${ECHO_T}no" >&6
9939 fi
9940
9941     fi
9942     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9943       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9944 set dummy ${ncn_progname}; ac_word=$2
9945 echo "$as_me:$LINENO: checking for $ac_word" >&5
9946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9947 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9948   echo $ECHO_N "(cached) $ECHO_C" >&6
9949 else
9950   if test -n "$AS_FOR_TARGET"; then
9951   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9952 else
9953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9954 for as_dir in $PATH
9955 do
9956   IFS=$as_save_IFS
9957   test -z "$as_dir" && as_dir=.
9958   for ac_exec_ext in '' $ac_executable_extensions; do
9959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9960     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9962     break 2
9963   fi
9964 done
9965 done
9966
9967 fi
9968 fi
9969 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9970 if test -n "$AS_FOR_TARGET"; then
9971   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9972 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9973 else
9974   echo "$as_me:$LINENO: result: no" >&5
9975 echo "${ECHO_T}no" >&6
9976 fi
9977
9978     fi
9979     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9980   done
9981 fi
9982
9983 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9984   set dummy as
9985   if test $build = $target ; then
9986     AS_FOR_TARGET="$2"
9987   else
9988     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9989   fi
9990 else
9991   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9992 fi
9993
9994 else
9995   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9996 fi
9997
9998
9999
10000
10001 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10002   if test -n "$with_build_time_tools"; then
10003     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
10004 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
10005     if test -x $with_build_time_tools/dlltool; then
10006       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
10007       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10008       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
10009 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
10010     else
10011       echo "$as_me:$LINENO: result: no" >&5
10012 echo "${ECHO_T}no" >&6
10013     fi
10014   elif test $build != $host && test $have_gcc_for_target = yes; then
10015     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
10016     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
10017     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10018   fi
10019 fi
10020 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10021   # Extract the first word of "dlltool", so it can be a program name with args.
10022 set dummy dlltool; ac_word=$2
10023 echo "$as_me:$LINENO: checking for $ac_word" >&5
10024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10025 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
10026   echo $ECHO_N "(cached) $ECHO_C" >&6
10027 else
10028   case $DLLTOOL_FOR_TARGET in
10029   [\\/]* | ?:[\\/]*)
10030   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
10031   ;;
10032   *)
10033   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10034 for as_dir in $gcc_cv_tool_dirs
10035 do
10036   IFS=$as_save_IFS
10037   test -z "$as_dir" && as_dir=.
10038   for ac_exec_ext in '' $ac_executable_extensions; do
10039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10040     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10042     break 2
10043   fi
10044 done
10045 done
10046
10047   ;;
10048 esac
10049 fi
10050 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10051
10052 if test -n "$DLLTOOL_FOR_TARGET"; then
10053   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10054 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10055 else
10056   echo "$as_me:$LINENO: result: no" >&5
10057 echo "${ECHO_T}no" >&6
10058 fi
10059
10060 fi
10061 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10062
10063
10064 if test -n "$DLLTOOL_FOR_TARGET"; then
10065   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10066 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10067   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10068 fi
10069
10070 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10071   for ncn_progname in dlltool; do
10072     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10073 set dummy ${ncn_progname}; ac_word=$2
10074 echo "$as_me:$LINENO: checking for $ac_word" >&5
10075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10076 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10077   echo $ECHO_N "(cached) $ECHO_C" >&6
10078 else
10079   if test -n "$DLLTOOL_FOR_TARGET"; then
10080   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10081 else
10082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10083 for as_dir in $PATH
10084 do
10085   IFS=$as_save_IFS
10086   test -z "$as_dir" && as_dir=.
10087   for ac_exec_ext in '' $ac_executable_extensions; do
10088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10089     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10091     break 2
10092   fi
10093 done
10094 done
10095
10096 fi
10097 fi
10098 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10099 if test -n "$DLLTOOL_FOR_TARGET"; then
10100   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10101 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10102 else
10103   echo "$as_me:$LINENO: result: no" >&5
10104 echo "${ECHO_T}no" >&6
10105 fi
10106
10107   done
10108 fi
10109
10110 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10111   for ncn_progname in dlltool; do
10112     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10113 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10114     if test -x $with_build_time_tools/${ncn_progname}; then
10115       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10116       echo "$as_me:$LINENO: result: yes" >&5
10117 echo "${ECHO_T}yes" >&6
10118       break
10119     else
10120       echo "$as_me:$LINENO: result: no" >&5
10121 echo "${ECHO_T}no" >&6
10122     fi
10123   done
10124 fi
10125
10126 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10127   for ncn_progname in dlltool; do
10128     if test -n "$ncn_target_tool_prefix"; then
10129       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10130 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10131 echo "$as_me:$LINENO: checking for $ac_word" >&5
10132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10133 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10134   echo $ECHO_N "(cached) $ECHO_C" >&6
10135 else
10136   if test -n "$DLLTOOL_FOR_TARGET"; then
10137   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10138 else
10139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10140 for as_dir in $PATH
10141 do
10142   IFS=$as_save_IFS
10143   test -z "$as_dir" && as_dir=.
10144   for ac_exec_ext in '' $ac_executable_extensions; do
10145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10146     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10148     break 2
10149   fi
10150 done
10151 done
10152
10153 fi
10154 fi
10155 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10156 if test -n "$DLLTOOL_FOR_TARGET"; then
10157   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10158 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10159 else
10160   echo "$as_me:$LINENO: result: no" >&5
10161 echo "${ECHO_T}no" >&6
10162 fi
10163
10164     fi
10165     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10166       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10167 set dummy ${ncn_progname}; ac_word=$2
10168 echo "$as_me:$LINENO: checking for $ac_word" >&5
10169 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10170 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10171   echo $ECHO_N "(cached) $ECHO_C" >&6
10172 else
10173   if test -n "$DLLTOOL_FOR_TARGET"; then
10174   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10175 else
10176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10177 for as_dir in $PATH
10178 do
10179   IFS=$as_save_IFS
10180   test -z "$as_dir" && as_dir=.
10181   for ac_exec_ext in '' $ac_executable_extensions; do
10182   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10183     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10184     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10185     break 2
10186   fi
10187 done
10188 done
10189
10190 fi
10191 fi
10192 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10193 if test -n "$DLLTOOL_FOR_TARGET"; then
10194   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10195 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10196 else
10197   echo "$as_me:$LINENO: result: no" >&5
10198 echo "${ECHO_T}no" >&6
10199 fi
10200
10201     fi
10202     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10203   done
10204 fi
10205
10206 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10207   set dummy dlltool
10208   if test $build = $target ; then
10209     DLLTOOL_FOR_TARGET="$2"
10210   else
10211     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10212   fi
10213 else
10214   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10215 fi
10216
10217 else
10218   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10219 fi
10220
10221
10222
10223
10224 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10225   if test -n "$with_build_time_tools"; then
10226     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10227 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10228     if test -x $with_build_time_tools/ld; then
10229       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10230       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10231       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10232 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10233     else
10234       echo "$as_me:$LINENO: result: no" >&5
10235 echo "${ECHO_T}no" >&6
10236     fi
10237   elif test $build != $host && test $have_gcc_for_target = yes; then
10238     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10239     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10240     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10241   fi
10242 fi
10243 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10244   # Extract the first word of "ld", so it can be a program name with args.
10245 set dummy ld; ac_word=$2
10246 echo "$as_me:$LINENO: checking for $ac_word" >&5
10247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10248 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10249   echo $ECHO_N "(cached) $ECHO_C" >&6
10250 else
10251   case $LD_FOR_TARGET in
10252   [\\/]* | ?:[\\/]*)
10253   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10254   ;;
10255   *)
10256   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10257 for as_dir in $gcc_cv_tool_dirs
10258 do
10259   IFS=$as_save_IFS
10260   test -z "$as_dir" && as_dir=.
10261   for ac_exec_ext in '' $ac_executable_extensions; do
10262   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10263     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10265     break 2
10266   fi
10267 done
10268 done
10269
10270   ;;
10271 esac
10272 fi
10273 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10274
10275 if test -n "$LD_FOR_TARGET"; then
10276   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10277 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10278 else
10279   echo "$as_me:$LINENO: result: no" >&5
10280 echo "${ECHO_T}no" >&6
10281 fi
10282
10283 fi
10284 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10285
10286
10287 if test -n "$LD_FOR_TARGET"; then
10288   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10289 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10290   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10291 fi
10292
10293 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10294   for ncn_progname in ld; do
10295     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10296 set dummy ${ncn_progname}; ac_word=$2
10297 echo "$as_me:$LINENO: checking for $ac_word" >&5
10298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10299 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10300   echo $ECHO_N "(cached) $ECHO_C" >&6
10301 else
10302   if test -n "$LD_FOR_TARGET"; then
10303   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10304 else
10305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10306 for as_dir in $PATH
10307 do
10308   IFS=$as_save_IFS
10309   test -z "$as_dir" && as_dir=.
10310   for ac_exec_ext in '' $ac_executable_extensions; do
10311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10312     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10314     break 2
10315   fi
10316 done
10317 done
10318
10319 fi
10320 fi
10321 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10322 if test -n "$LD_FOR_TARGET"; then
10323   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10324 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10325 else
10326   echo "$as_me:$LINENO: result: no" >&5
10327 echo "${ECHO_T}no" >&6
10328 fi
10329
10330   done
10331 fi
10332
10333 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10334   for ncn_progname in ld; do
10335     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10336 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10337     if test -x $with_build_time_tools/${ncn_progname}; then
10338       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10339       echo "$as_me:$LINENO: result: yes" >&5
10340 echo "${ECHO_T}yes" >&6
10341       break
10342     else
10343       echo "$as_me:$LINENO: result: no" >&5
10344 echo "${ECHO_T}no" >&6
10345     fi
10346   done
10347 fi
10348
10349 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10350   for ncn_progname in ld; do
10351     if test -n "$ncn_target_tool_prefix"; then
10352       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10353 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10354 echo "$as_me:$LINENO: checking for $ac_word" >&5
10355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10356 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10357   echo $ECHO_N "(cached) $ECHO_C" >&6
10358 else
10359   if test -n "$LD_FOR_TARGET"; then
10360   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10361 else
10362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10363 for as_dir in $PATH
10364 do
10365   IFS=$as_save_IFS
10366   test -z "$as_dir" && as_dir=.
10367   for ac_exec_ext in '' $ac_executable_extensions; do
10368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10369     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10371     break 2
10372   fi
10373 done
10374 done
10375
10376 fi
10377 fi
10378 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10379 if test -n "$LD_FOR_TARGET"; then
10380   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10381 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10382 else
10383   echo "$as_me:$LINENO: result: no" >&5
10384 echo "${ECHO_T}no" >&6
10385 fi
10386
10387     fi
10388     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10389       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10390 set dummy ${ncn_progname}; ac_word=$2
10391 echo "$as_me:$LINENO: checking for $ac_word" >&5
10392 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10393 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10394   echo $ECHO_N "(cached) $ECHO_C" >&6
10395 else
10396   if test -n "$LD_FOR_TARGET"; then
10397   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10398 else
10399 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10400 for as_dir in $PATH
10401 do
10402   IFS=$as_save_IFS
10403   test -z "$as_dir" && as_dir=.
10404   for ac_exec_ext in '' $ac_executable_extensions; do
10405   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10406     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10407     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10408     break 2
10409   fi
10410 done
10411 done
10412
10413 fi
10414 fi
10415 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10416 if test -n "$LD_FOR_TARGET"; then
10417   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10418 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10419 else
10420   echo "$as_me:$LINENO: result: no" >&5
10421 echo "${ECHO_T}no" >&6
10422 fi
10423
10424     fi
10425     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10426   done
10427 fi
10428
10429 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10430   set dummy ld
10431   if test $build = $target ; then
10432     LD_FOR_TARGET="$2"
10433   else
10434     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10435   fi
10436 else
10437   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10438 fi
10439
10440 else
10441   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10442 fi
10443
10444
10445
10446
10447 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10448   if test -n "$with_build_time_tools"; then
10449     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10450 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10451     if test -x $with_build_time_tools/lipo; then
10452       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10453       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10454       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10455 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10456     else
10457       echo "$as_me:$LINENO: result: no" >&5
10458 echo "${ECHO_T}no" >&6
10459     fi
10460   elif test $build != $host && test $have_gcc_for_target = yes; then
10461     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10462     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10463     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10464   fi
10465 fi
10466 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10467   # Extract the first word of "lipo", so it can be a program name with args.
10468 set dummy lipo; ac_word=$2
10469 echo "$as_me:$LINENO: checking for $ac_word" >&5
10470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10471 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10472   echo $ECHO_N "(cached) $ECHO_C" >&6
10473 else
10474   case $LIPO_FOR_TARGET in
10475   [\\/]* | ?:[\\/]*)
10476   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10477   ;;
10478   *)
10479   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10480 for as_dir in $gcc_cv_tool_dirs
10481 do
10482   IFS=$as_save_IFS
10483   test -z "$as_dir" && as_dir=.
10484   for ac_exec_ext in '' $ac_executable_extensions; do
10485   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10486     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10487     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10488     break 2
10489   fi
10490 done
10491 done
10492
10493   ;;
10494 esac
10495 fi
10496 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10497
10498 if test -n "$LIPO_FOR_TARGET"; then
10499   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10500 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10501 else
10502   echo "$as_me:$LINENO: result: no" >&5
10503 echo "${ECHO_T}no" >&6
10504 fi
10505
10506 fi
10507 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10508
10509
10510 if test -n "$LIPO_FOR_TARGET"; then
10511   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10512 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10513   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10514 fi
10515
10516 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10517   for ncn_progname in lipo; do
10518     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10519 set dummy ${ncn_progname}; ac_word=$2
10520 echo "$as_me:$LINENO: checking for $ac_word" >&5
10521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10522 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10523   echo $ECHO_N "(cached) $ECHO_C" >&6
10524 else
10525   if test -n "$LIPO_FOR_TARGET"; then
10526   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10527 else
10528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10529 for as_dir in $PATH
10530 do
10531   IFS=$as_save_IFS
10532   test -z "$as_dir" && as_dir=.
10533   for ac_exec_ext in '' $ac_executable_extensions; do
10534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10535     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10537     break 2
10538   fi
10539 done
10540 done
10541
10542 fi
10543 fi
10544 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10545 if test -n "$LIPO_FOR_TARGET"; then
10546   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10547 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10548 else
10549   echo "$as_me:$LINENO: result: no" >&5
10550 echo "${ECHO_T}no" >&6
10551 fi
10552
10553   done
10554 fi
10555
10556 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10557   for ncn_progname in lipo; do
10558     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10559 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10560     if test -x $with_build_time_tools/${ncn_progname}; then
10561       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10562       echo "$as_me:$LINENO: result: yes" >&5
10563 echo "${ECHO_T}yes" >&6
10564       break
10565     else
10566       echo "$as_me:$LINENO: result: no" >&5
10567 echo "${ECHO_T}no" >&6
10568     fi
10569   done
10570 fi
10571
10572 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10573   for ncn_progname in lipo; do
10574     if test -n "$ncn_target_tool_prefix"; then
10575       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10576 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10577 echo "$as_me:$LINENO: checking for $ac_word" >&5
10578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10579 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10580   echo $ECHO_N "(cached) $ECHO_C" >&6
10581 else
10582   if test -n "$LIPO_FOR_TARGET"; then
10583   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10584 else
10585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10586 for as_dir in $PATH
10587 do
10588   IFS=$as_save_IFS
10589   test -z "$as_dir" && as_dir=.
10590   for ac_exec_ext in '' $ac_executable_extensions; do
10591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10592     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10594     break 2
10595   fi
10596 done
10597 done
10598
10599 fi
10600 fi
10601 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10602 if test -n "$LIPO_FOR_TARGET"; then
10603   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10604 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10605 else
10606   echo "$as_me:$LINENO: result: no" >&5
10607 echo "${ECHO_T}no" >&6
10608 fi
10609
10610     fi
10611     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10612       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10613 set dummy ${ncn_progname}; ac_word=$2
10614 echo "$as_me:$LINENO: checking for $ac_word" >&5
10615 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10616 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10617   echo $ECHO_N "(cached) $ECHO_C" >&6
10618 else
10619   if test -n "$LIPO_FOR_TARGET"; then
10620   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10621 else
10622 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10623 for as_dir in $PATH
10624 do
10625   IFS=$as_save_IFS
10626   test -z "$as_dir" && as_dir=.
10627   for ac_exec_ext in '' $ac_executable_extensions; do
10628   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10629     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10630     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10631     break 2
10632   fi
10633 done
10634 done
10635
10636 fi
10637 fi
10638 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10639 if test -n "$LIPO_FOR_TARGET"; then
10640   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10641 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10642 else
10643   echo "$as_me:$LINENO: result: no" >&5
10644 echo "${ECHO_T}no" >&6
10645 fi
10646
10647     fi
10648     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10649   done
10650 fi
10651
10652 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10653   set dummy lipo
10654   if test $build = $target ; then
10655     LIPO_FOR_TARGET="$2"
10656   else
10657     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10658   fi
10659 else
10660   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10661 fi
10662
10663 else
10664   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10665 fi
10666
10667
10668
10669
10670 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10671   if test -n "$with_build_time_tools"; then
10672     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10673 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10674     if test -x $with_build_time_tools/nm; then
10675       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10676       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10677       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10678 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10679     else
10680       echo "$as_me:$LINENO: result: no" >&5
10681 echo "${ECHO_T}no" >&6
10682     fi
10683   elif test $build != $host && test $have_gcc_for_target = yes; then
10684     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10685     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10686     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10687   fi
10688 fi
10689 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10690   # Extract the first word of "nm", so it can be a program name with args.
10691 set dummy nm; ac_word=$2
10692 echo "$as_me:$LINENO: checking for $ac_word" >&5
10693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10694 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10695   echo $ECHO_N "(cached) $ECHO_C" >&6
10696 else
10697   case $NM_FOR_TARGET in
10698   [\\/]* | ?:[\\/]*)
10699   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10700   ;;
10701   *)
10702   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10703 for as_dir in $gcc_cv_tool_dirs
10704 do
10705   IFS=$as_save_IFS
10706   test -z "$as_dir" && as_dir=.
10707   for ac_exec_ext in '' $ac_executable_extensions; do
10708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10709     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10711     break 2
10712   fi
10713 done
10714 done
10715
10716   ;;
10717 esac
10718 fi
10719 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10720
10721 if test -n "$NM_FOR_TARGET"; then
10722   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10723 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10724 else
10725   echo "$as_me:$LINENO: result: no" >&5
10726 echo "${ECHO_T}no" >&6
10727 fi
10728
10729 fi
10730 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10731
10732
10733 if test -n "$NM_FOR_TARGET"; then
10734   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10735 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10736   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10737 fi
10738
10739 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10740   for ncn_progname in nm; do
10741     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10742 set dummy ${ncn_progname}; ac_word=$2
10743 echo "$as_me:$LINENO: checking for $ac_word" >&5
10744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10745 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10746   echo $ECHO_N "(cached) $ECHO_C" >&6
10747 else
10748   if test -n "$NM_FOR_TARGET"; then
10749   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10750 else
10751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10752 for as_dir in $PATH
10753 do
10754   IFS=$as_save_IFS
10755   test -z "$as_dir" && as_dir=.
10756   for ac_exec_ext in '' $ac_executable_extensions; do
10757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10758     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10760     break 2
10761   fi
10762 done
10763 done
10764
10765 fi
10766 fi
10767 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10768 if test -n "$NM_FOR_TARGET"; then
10769   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10770 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10771 else
10772   echo "$as_me:$LINENO: result: no" >&5
10773 echo "${ECHO_T}no" >&6
10774 fi
10775
10776   done
10777 fi
10778
10779 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10780   for ncn_progname in nm; do
10781     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10782 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10783     if test -x $with_build_time_tools/${ncn_progname}; then
10784       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10785       echo "$as_me:$LINENO: result: yes" >&5
10786 echo "${ECHO_T}yes" >&6
10787       break
10788     else
10789       echo "$as_me:$LINENO: result: no" >&5
10790 echo "${ECHO_T}no" >&6
10791     fi
10792   done
10793 fi
10794
10795 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10796   for ncn_progname in nm; do
10797     if test -n "$ncn_target_tool_prefix"; then
10798       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10799 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10800 echo "$as_me:$LINENO: checking for $ac_word" >&5
10801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10802 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10803   echo $ECHO_N "(cached) $ECHO_C" >&6
10804 else
10805   if test -n "$NM_FOR_TARGET"; then
10806   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10807 else
10808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10809 for as_dir in $PATH
10810 do
10811   IFS=$as_save_IFS
10812   test -z "$as_dir" && as_dir=.
10813   for ac_exec_ext in '' $ac_executable_extensions; do
10814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10815     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10817     break 2
10818   fi
10819 done
10820 done
10821
10822 fi
10823 fi
10824 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10825 if test -n "$NM_FOR_TARGET"; then
10826   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10827 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10828 else
10829   echo "$as_me:$LINENO: result: no" >&5
10830 echo "${ECHO_T}no" >&6
10831 fi
10832
10833     fi
10834     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10835       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10836 set dummy ${ncn_progname}; ac_word=$2
10837 echo "$as_me:$LINENO: checking for $ac_word" >&5
10838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10839 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10840   echo $ECHO_N "(cached) $ECHO_C" >&6
10841 else
10842   if test -n "$NM_FOR_TARGET"; then
10843   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10844 else
10845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10846 for as_dir in $PATH
10847 do
10848   IFS=$as_save_IFS
10849   test -z "$as_dir" && as_dir=.
10850   for ac_exec_ext in '' $ac_executable_extensions; do
10851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10852     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10854     break 2
10855   fi
10856 done
10857 done
10858
10859 fi
10860 fi
10861 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10862 if test -n "$NM_FOR_TARGET"; then
10863   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10864 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10865 else
10866   echo "$as_me:$LINENO: result: no" >&5
10867 echo "${ECHO_T}no" >&6
10868 fi
10869
10870     fi
10871     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10872   done
10873 fi
10874
10875 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10876   set dummy nm
10877   if test $build = $target ; then
10878     NM_FOR_TARGET="$2"
10879   else
10880     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10881   fi
10882 else
10883   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10884 fi
10885
10886 else
10887   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10888 fi
10889
10890
10891
10892
10893 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10894   if test -n "$with_build_time_tools"; then
10895     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10896 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10897     if test -x $with_build_time_tools/objdump; then
10898       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10899       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10900       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10901 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10902     else
10903       echo "$as_me:$LINENO: result: no" >&5
10904 echo "${ECHO_T}no" >&6
10905     fi
10906   elif test $build != $host && test $have_gcc_for_target = yes; then
10907     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10908     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10909     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10910   fi
10911 fi
10912 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10913   # Extract the first word of "objdump", so it can be a program name with args.
10914 set dummy objdump; ac_word=$2
10915 echo "$as_me:$LINENO: checking for $ac_word" >&5
10916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10917 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10918   echo $ECHO_N "(cached) $ECHO_C" >&6
10919 else
10920   case $OBJDUMP_FOR_TARGET in
10921   [\\/]* | ?:[\\/]*)
10922   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10923   ;;
10924   *)
10925   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10926 for as_dir in $gcc_cv_tool_dirs
10927 do
10928   IFS=$as_save_IFS
10929   test -z "$as_dir" && as_dir=.
10930   for ac_exec_ext in '' $ac_executable_extensions; do
10931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10932     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10934     break 2
10935   fi
10936 done
10937 done
10938
10939   ;;
10940 esac
10941 fi
10942 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10943
10944 if test -n "$OBJDUMP_FOR_TARGET"; then
10945   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10946 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10947 else
10948   echo "$as_me:$LINENO: result: no" >&5
10949 echo "${ECHO_T}no" >&6
10950 fi
10951
10952 fi
10953 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10954
10955
10956 if test -n "$OBJDUMP_FOR_TARGET"; then
10957   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10958 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10959   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10960 fi
10961
10962 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10963   for ncn_progname in objdump; do
10964     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10965 set dummy ${ncn_progname}; ac_word=$2
10966 echo "$as_me:$LINENO: checking for $ac_word" >&5
10967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10968 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10969   echo $ECHO_N "(cached) $ECHO_C" >&6
10970 else
10971   if test -n "$OBJDUMP_FOR_TARGET"; then
10972   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10973 else
10974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10975 for as_dir in $PATH
10976 do
10977   IFS=$as_save_IFS
10978   test -z "$as_dir" && as_dir=.
10979   for ac_exec_ext in '' $ac_executable_extensions; do
10980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10981     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10983     break 2
10984   fi
10985 done
10986 done
10987
10988 fi
10989 fi
10990 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10991 if test -n "$OBJDUMP_FOR_TARGET"; then
10992   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10993 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10994 else
10995   echo "$as_me:$LINENO: result: no" >&5
10996 echo "${ECHO_T}no" >&6
10997 fi
10998
10999   done
11000 fi
11001
11002 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11003   for ncn_progname in objdump; do
11004     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11005 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11006     if test -x $with_build_time_tools/${ncn_progname}; then
11007       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11008       echo "$as_me:$LINENO: result: yes" >&5
11009 echo "${ECHO_T}yes" >&6
11010       break
11011     else
11012       echo "$as_me:$LINENO: result: no" >&5
11013 echo "${ECHO_T}no" >&6
11014     fi
11015   done
11016 fi
11017
11018 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
11019   for ncn_progname in objdump; do
11020     if test -n "$ncn_target_tool_prefix"; then
11021       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11022 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11023 echo "$as_me:$LINENO: checking for $ac_word" >&5
11024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11025 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11026   echo $ECHO_N "(cached) $ECHO_C" >&6
11027 else
11028   if test -n "$OBJDUMP_FOR_TARGET"; then
11029   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11030 else
11031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11032 for as_dir in $PATH
11033 do
11034   IFS=$as_save_IFS
11035   test -z "$as_dir" && as_dir=.
11036   for ac_exec_ext in '' $ac_executable_extensions; do
11037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11038     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11040     break 2
11041   fi
11042 done
11043 done
11044
11045 fi
11046 fi
11047 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11048 if test -n "$OBJDUMP_FOR_TARGET"; then
11049   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11050 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11051 else
11052   echo "$as_me:$LINENO: result: no" >&5
11053 echo "${ECHO_T}no" >&6
11054 fi
11055
11056     fi
11057     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
11058       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11059 set dummy ${ncn_progname}; ac_word=$2
11060 echo "$as_me:$LINENO: checking for $ac_word" >&5
11061 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11062 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11063   echo $ECHO_N "(cached) $ECHO_C" >&6
11064 else
11065   if test -n "$OBJDUMP_FOR_TARGET"; then
11066   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11067 else
11068 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11069 for as_dir in $PATH
11070 do
11071   IFS=$as_save_IFS
11072   test -z "$as_dir" && as_dir=.
11073   for ac_exec_ext in '' $ac_executable_extensions; do
11074   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11075     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
11076     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11077     break 2
11078   fi
11079 done
11080 done
11081
11082 fi
11083 fi
11084 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11085 if test -n "$OBJDUMP_FOR_TARGET"; then
11086   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11087 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11088 else
11089   echo "$as_me:$LINENO: result: no" >&5
11090 echo "${ECHO_T}no" >&6
11091 fi
11092
11093     fi
11094     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11095   done
11096 fi
11097
11098 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11099   set dummy objdump
11100   if test $build = $target ; then
11101     OBJDUMP_FOR_TARGET="$2"
11102   else
11103     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11104   fi
11105 else
11106   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11107 fi
11108
11109 else
11110   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11111 fi
11112
11113
11114
11115
11116 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11117   if test -n "$with_build_time_tools"; then
11118     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11119 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11120     if test -x $with_build_time_tools/ranlib; then
11121       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11122       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11123       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11124 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11125     else
11126       echo "$as_me:$LINENO: result: no" >&5
11127 echo "${ECHO_T}no" >&6
11128     fi
11129   elif test $build != $host && test $have_gcc_for_target = yes; then
11130     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11131     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11132     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11133   fi
11134 fi
11135 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11136   # Extract the first word of "ranlib", so it can be a program name with args.
11137 set dummy ranlib; ac_word=$2
11138 echo "$as_me:$LINENO: checking for $ac_word" >&5
11139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11140 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11141   echo $ECHO_N "(cached) $ECHO_C" >&6
11142 else
11143   case $RANLIB_FOR_TARGET in
11144   [\\/]* | ?:[\\/]*)
11145   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11146   ;;
11147   *)
11148   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11149 for as_dir in $gcc_cv_tool_dirs
11150 do
11151   IFS=$as_save_IFS
11152   test -z "$as_dir" && as_dir=.
11153   for ac_exec_ext in '' $ac_executable_extensions; do
11154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11155     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11157     break 2
11158   fi
11159 done
11160 done
11161
11162   ;;
11163 esac
11164 fi
11165 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11166
11167 if test -n "$RANLIB_FOR_TARGET"; then
11168   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11169 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11170 else
11171   echo "$as_me:$LINENO: result: no" >&5
11172 echo "${ECHO_T}no" >&6
11173 fi
11174
11175 fi
11176 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11177
11178
11179 if test -n "$RANLIB_FOR_TARGET"; then
11180   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11181 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11182   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11183 fi
11184
11185 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11186   for ncn_progname in ranlib; do
11187     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11188 set dummy ${ncn_progname}; ac_word=$2
11189 echo "$as_me:$LINENO: checking for $ac_word" >&5
11190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11191 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11192   echo $ECHO_N "(cached) $ECHO_C" >&6
11193 else
11194   if test -n "$RANLIB_FOR_TARGET"; then
11195   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11196 else
11197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11198 for as_dir in $PATH
11199 do
11200   IFS=$as_save_IFS
11201   test -z "$as_dir" && as_dir=.
11202   for ac_exec_ext in '' $ac_executable_extensions; do
11203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11204     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11206     break 2
11207   fi
11208 done
11209 done
11210
11211 fi
11212 fi
11213 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11214 if test -n "$RANLIB_FOR_TARGET"; then
11215   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11216 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11217 else
11218   echo "$as_me:$LINENO: result: no" >&5
11219 echo "${ECHO_T}no" >&6
11220 fi
11221
11222   done
11223 fi
11224
11225 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11226   for ncn_progname in ranlib; do
11227     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11228 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11229     if test -x $with_build_time_tools/${ncn_progname}; then
11230       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11231       echo "$as_me:$LINENO: result: yes" >&5
11232 echo "${ECHO_T}yes" >&6
11233       break
11234     else
11235       echo "$as_me:$LINENO: result: no" >&5
11236 echo "${ECHO_T}no" >&6
11237     fi
11238   done
11239 fi
11240
11241 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11242   for ncn_progname in ranlib; do
11243     if test -n "$ncn_target_tool_prefix"; then
11244       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11245 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11246 echo "$as_me:$LINENO: checking for $ac_word" >&5
11247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11248 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11249   echo $ECHO_N "(cached) $ECHO_C" >&6
11250 else
11251   if test -n "$RANLIB_FOR_TARGET"; then
11252   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11253 else
11254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11255 for as_dir in $PATH
11256 do
11257   IFS=$as_save_IFS
11258   test -z "$as_dir" && as_dir=.
11259   for ac_exec_ext in '' $ac_executable_extensions; do
11260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11261     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11263     break 2
11264   fi
11265 done
11266 done
11267
11268 fi
11269 fi
11270 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11271 if test -n "$RANLIB_FOR_TARGET"; then
11272   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11273 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11274 else
11275   echo "$as_me:$LINENO: result: no" >&5
11276 echo "${ECHO_T}no" >&6
11277 fi
11278
11279     fi
11280     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11281       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11282 set dummy ${ncn_progname}; ac_word=$2
11283 echo "$as_me:$LINENO: checking for $ac_word" >&5
11284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11285 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11286   echo $ECHO_N "(cached) $ECHO_C" >&6
11287 else
11288   if test -n "$RANLIB_FOR_TARGET"; then
11289   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11290 else
11291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11292 for as_dir in $PATH
11293 do
11294   IFS=$as_save_IFS
11295   test -z "$as_dir" && as_dir=.
11296   for ac_exec_ext in '' $ac_executable_extensions; do
11297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11298     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11300     break 2
11301   fi
11302 done
11303 done
11304
11305 fi
11306 fi
11307 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11308 if test -n "$RANLIB_FOR_TARGET"; then
11309   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11310 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11311 else
11312   echo "$as_me:$LINENO: result: no" >&5
11313 echo "${ECHO_T}no" >&6
11314 fi
11315
11316     fi
11317     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11318   done
11319 fi
11320
11321 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11322   set dummy ranlib
11323   if test $build = $target ; then
11324     RANLIB_FOR_TARGET="$2"
11325   else
11326     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11327   fi
11328 else
11329   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11330 fi
11331
11332 else
11333   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11334 fi
11335
11336
11337
11338
11339 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11340   if test -n "$with_build_time_tools"; then
11341     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11342 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11343     if test -x $with_build_time_tools/strip; then
11344       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11345       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11346       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11347 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11348     else
11349       echo "$as_me:$LINENO: result: no" >&5
11350 echo "${ECHO_T}no" >&6
11351     fi
11352   elif test $build != $host && test $have_gcc_for_target = yes; then
11353     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11354     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11355     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11356   fi
11357 fi
11358 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11359   # Extract the first word of "strip", so it can be a program name with args.
11360 set dummy strip; ac_word=$2
11361 echo "$as_me:$LINENO: checking for $ac_word" >&5
11362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11363 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11364   echo $ECHO_N "(cached) $ECHO_C" >&6
11365 else
11366   case $STRIP_FOR_TARGET in
11367   [\\/]* | ?:[\\/]*)
11368   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11369   ;;
11370   *)
11371   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11372 for as_dir in $gcc_cv_tool_dirs
11373 do
11374   IFS=$as_save_IFS
11375   test -z "$as_dir" && as_dir=.
11376   for ac_exec_ext in '' $ac_executable_extensions; do
11377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11378     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11380     break 2
11381   fi
11382 done
11383 done
11384
11385   ;;
11386 esac
11387 fi
11388 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11389
11390 if test -n "$STRIP_FOR_TARGET"; then
11391   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11392 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11393 else
11394   echo "$as_me:$LINENO: result: no" >&5
11395 echo "${ECHO_T}no" >&6
11396 fi
11397
11398 fi
11399 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11400
11401
11402 if test -n "$STRIP_FOR_TARGET"; then
11403   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11404 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11405   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11406 fi
11407
11408 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11409   for ncn_progname in strip; do
11410     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11411 set dummy ${ncn_progname}; ac_word=$2
11412 echo "$as_me:$LINENO: checking for $ac_word" >&5
11413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11414 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11415   echo $ECHO_N "(cached) $ECHO_C" >&6
11416 else
11417   if test -n "$STRIP_FOR_TARGET"; then
11418   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11419 else
11420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11421 for as_dir in $PATH
11422 do
11423   IFS=$as_save_IFS
11424   test -z "$as_dir" && as_dir=.
11425   for ac_exec_ext in '' $ac_executable_extensions; do
11426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11427     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11429     break 2
11430   fi
11431 done
11432 done
11433
11434 fi
11435 fi
11436 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11437 if test -n "$STRIP_FOR_TARGET"; then
11438   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11439 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11440 else
11441   echo "$as_me:$LINENO: result: no" >&5
11442 echo "${ECHO_T}no" >&6
11443 fi
11444
11445   done
11446 fi
11447
11448 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11449   for ncn_progname in strip; do
11450     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11451 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11452     if test -x $with_build_time_tools/${ncn_progname}; then
11453       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11454       echo "$as_me:$LINENO: result: yes" >&5
11455 echo "${ECHO_T}yes" >&6
11456       break
11457     else
11458       echo "$as_me:$LINENO: result: no" >&5
11459 echo "${ECHO_T}no" >&6
11460     fi
11461   done
11462 fi
11463
11464 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11465   for ncn_progname in strip; do
11466     if test -n "$ncn_target_tool_prefix"; then
11467       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11468 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11469 echo "$as_me:$LINENO: checking for $ac_word" >&5
11470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11471 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11472   echo $ECHO_N "(cached) $ECHO_C" >&6
11473 else
11474   if test -n "$STRIP_FOR_TARGET"; then
11475   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11476 else
11477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11478 for as_dir in $PATH
11479 do
11480   IFS=$as_save_IFS
11481   test -z "$as_dir" && as_dir=.
11482   for ac_exec_ext in '' $ac_executable_extensions; do
11483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11484     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11486     break 2
11487   fi
11488 done
11489 done
11490
11491 fi
11492 fi
11493 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11494 if test -n "$STRIP_FOR_TARGET"; then
11495   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11496 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11497 else
11498   echo "$as_me:$LINENO: result: no" >&5
11499 echo "${ECHO_T}no" >&6
11500 fi
11501
11502     fi
11503     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11504       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11505 set dummy ${ncn_progname}; ac_word=$2
11506 echo "$as_me:$LINENO: checking for $ac_word" >&5
11507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11508 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11509   echo $ECHO_N "(cached) $ECHO_C" >&6
11510 else
11511   if test -n "$STRIP_FOR_TARGET"; then
11512   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11513 else
11514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11515 for as_dir in $PATH
11516 do
11517   IFS=$as_save_IFS
11518   test -z "$as_dir" && as_dir=.
11519   for ac_exec_ext in '' $ac_executable_extensions; do
11520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11521     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11523     break 2
11524   fi
11525 done
11526 done
11527
11528 fi
11529 fi
11530 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11531 if test -n "$STRIP_FOR_TARGET"; then
11532   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11533 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11534 else
11535   echo "$as_me:$LINENO: result: no" >&5
11536 echo "${ECHO_T}no" >&6
11537 fi
11538
11539     fi
11540     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11541   done
11542 fi
11543
11544 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11545   set dummy strip
11546   if test $build = $target ; then
11547     STRIP_FOR_TARGET="$2"
11548   else
11549     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11550   fi
11551 else
11552   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11553 fi
11554
11555 else
11556   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11557 fi
11558
11559
11560
11561
11562 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11563   if test -n "$with_build_time_tools"; then
11564     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11565 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11566     if test -x $with_build_time_tools/windres; then
11567       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11568       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11569       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11570 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11571     else
11572       echo "$as_me:$LINENO: result: no" >&5
11573 echo "${ECHO_T}no" >&6
11574     fi
11575   elif test $build != $host && test $have_gcc_for_target = yes; then
11576     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11577     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11578     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11579   fi
11580 fi
11581 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11582   # Extract the first word of "windres", so it can be a program name with args.
11583 set dummy windres; ac_word=$2
11584 echo "$as_me:$LINENO: checking for $ac_word" >&5
11585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11586 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11587   echo $ECHO_N "(cached) $ECHO_C" >&6
11588 else
11589   case $WINDRES_FOR_TARGET in
11590   [\\/]* | ?:[\\/]*)
11591   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11592   ;;
11593   *)
11594   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11595 for as_dir in $gcc_cv_tool_dirs
11596 do
11597   IFS=$as_save_IFS
11598   test -z "$as_dir" && as_dir=.
11599   for ac_exec_ext in '' $ac_executable_extensions; do
11600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11601     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11603     break 2
11604   fi
11605 done
11606 done
11607
11608   ;;
11609 esac
11610 fi
11611 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11612
11613 if test -n "$WINDRES_FOR_TARGET"; then
11614   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11615 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11616 else
11617   echo "$as_me:$LINENO: result: no" >&5
11618 echo "${ECHO_T}no" >&6
11619 fi
11620
11621 fi
11622 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11623
11624
11625 if test -n "$WINDRES_FOR_TARGET"; then
11626   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11627 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11628   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11629 fi
11630
11631 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11632   for ncn_progname in windres; do
11633     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11634 set dummy ${ncn_progname}; ac_word=$2
11635 echo "$as_me:$LINENO: checking for $ac_word" >&5
11636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11637 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11638   echo $ECHO_N "(cached) $ECHO_C" >&6
11639 else
11640   if test -n "$WINDRES_FOR_TARGET"; then
11641   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11642 else
11643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11644 for as_dir in $PATH
11645 do
11646   IFS=$as_save_IFS
11647   test -z "$as_dir" && as_dir=.
11648   for ac_exec_ext in '' $ac_executable_extensions; do
11649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11650     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11652     break 2
11653   fi
11654 done
11655 done
11656
11657 fi
11658 fi
11659 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11660 if test -n "$WINDRES_FOR_TARGET"; then
11661   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11662 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11663 else
11664   echo "$as_me:$LINENO: result: no" >&5
11665 echo "${ECHO_T}no" >&6
11666 fi
11667
11668   done
11669 fi
11670
11671 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11672   for ncn_progname in windres; do
11673     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11674 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11675     if test -x $with_build_time_tools/${ncn_progname}; then
11676       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11677       echo "$as_me:$LINENO: result: yes" >&5
11678 echo "${ECHO_T}yes" >&6
11679       break
11680     else
11681       echo "$as_me:$LINENO: result: no" >&5
11682 echo "${ECHO_T}no" >&6
11683     fi
11684   done
11685 fi
11686
11687 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11688   for ncn_progname in windres; do
11689     if test -n "$ncn_target_tool_prefix"; then
11690       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11691 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11692 echo "$as_me:$LINENO: checking for $ac_word" >&5
11693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11694 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11695   echo $ECHO_N "(cached) $ECHO_C" >&6
11696 else
11697   if test -n "$WINDRES_FOR_TARGET"; then
11698   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11699 else
11700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11701 for as_dir in $PATH
11702 do
11703   IFS=$as_save_IFS
11704   test -z "$as_dir" && as_dir=.
11705   for ac_exec_ext in '' $ac_executable_extensions; do
11706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11707     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11709     break 2
11710   fi
11711 done
11712 done
11713
11714 fi
11715 fi
11716 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11717 if test -n "$WINDRES_FOR_TARGET"; then
11718   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11719 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11720 else
11721   echo "$as_me:$LINENO: result: no" >&5
11722 echo "${ECHO_T}no" >&6
11723 fi
11724
11725     fi
11726     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11727       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11728 set dummy ${ncn_progname}; ac_word=$2
11729 echo "$as_me:$LINENO: checking for $ac_word" >&5
11730 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11731 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11732   echo $ECHO_N "(cached) $ECHO_C" >&6
11733 else
11734   if test -n "$WINDRES_FOR_TARGET"; then
11735   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11736 else
11737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11738 for as_dir in $PATH
11739 do
11740   IFS=$as_save_IFS
11741   test -z "$as_dir" && as_dir=.
11742   for ac_exec_ext in '' $ac_executable_extensions; do
11743   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11744     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11745     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11746     break 2
11747   fi
11748 done
11749 done
11750
11751 fi
11752 fi
11753 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11754 if test -n "$WINDRES_FOR_TARGET"; then
11755   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11756 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11757 else
11758   echo "$as_me:$LINENO: result: no" >&5
11759 echo "${ECHO_T}no" >&6
11760 fi
11761
11762     fi
11763     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11764   done
11765 fi
11766
11767 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11768   set dummy windres
11769   if test $build = $target ; then
11770     WINDRES_FOR_TARGET="$2"
11771   else
11772     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11773   fi
11774 else
11775   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11776 fi
11777
11778 else
11779   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11780 fi
11781
11782
11783
11784
11785 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11786   if test -n "$with_build_time_tools"; then
11787     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11788 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11789     if test -x $with_build_time_tools/windmc; then
11790       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11791       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11792       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11793 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11794     else
11795       echo "$as_me:$LINENO: result: no" >&5
11796 echo "${ECHO_T}no" >&6
11797     fi
11798   elif test $build != $host && test $have_gcc_for_target = yes; then
11799     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11800     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11801     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11802   fi
11803 fi
11804 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11805   # Extract the first word of "windmc", so it can be a program name with args.
11806 set dummy windmc; ac_word=$2
11807 echo "$as_me:$LINENO: checking for $ac_word" >&5
11808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11809 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11810   echo $ECHO_N "(cached) $ECHO_C" >&6
11811 else
11812   case $WINDMC_FOR_TARGET in
11813   [\\/]* | ?:[\\/]*)
11814   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11815   ;;
11816   *)
11817   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11818 for as_dir in $gcc_cv_tool_dirs
11819 do
11820   IFS=$as_save_IFS
11821   test -z "$as_dir" && as_dir=.
11822   for ac_exec_ext in '' $ac_executable_extensions; do
11823   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11824     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11825     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11826     break 2
11827   fi
11828 done
11829 done
11830
11831   ;;
11832 esac
11833 fi
11834 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11835
11836 if test -n "$WINDMC_FOR_TARGET"; then
11837   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11838 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11839 else
11840   echo "$as_me:$LINENO: result: no" >&5
11841 echo "${ECHO_T}no" >&6
11842 fi
11843
11844 fi
11845 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11846
11847
11848 if test -n "$WINDMC_FOR_TARGET"; then
11849   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11850 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11851   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11852 fi
11853
11854 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11855   for ncn_progname in windmc; do
11856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11857 set dummy ${ncn_progname}; ac_word=$2
11858 echo "$as_me:$LINENO: checking for $ac_word" >&5
11859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11860 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11861   echo $ECHO_N "(cached) $ECHO_C" >&6
11862 else
11863   if test -n "$WINDMC_FOR_TARGET"; then
11864   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11865 else
11866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11867 for as_dir in $PATH
11868 do
11869   IFS=$as_save_IFS
11870   test -z "$as_dir" && as_dir=.
11871   for ac_exec_ext in '' $ac_executable_extensions; do
11872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11873     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11875     break 2
11876   fi
11877 done
11878 done
11879
11880 fi
11881 fi
11882 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11883 if test -n "$WINDMC_FOR_TARGET"; then
11884   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11885 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11886 else
11887   echo "$as_me:$LINENO: result: no" >&5
11888 echo "${ECHO_T}no" >&6
11889 fi
11890
11891   done
11892 fi
11893
11894 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11895   for ncn_progname in windmc; do
11896     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11897 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11898     if test -x $with_build_time_tools/${ncn_progname}; then
11899       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11900       echo "$as_me:$LINENO: result: yes" >&5
11901 echo "${ECHO_T}yes" >&6
11902       break
11903     else
11904       echo "$as_me:$LINENO: result: no" >&5
11905 echo "${ECHO_T}no" >&6
11906     fi
11907   done
11908 fi
11909
11910 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11911   for ncn_progname in windmc; do
11912     if test -n "$ncn_target_tool_prefix"; then
11913       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11914 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11915 echo "$as_me:$LINENO: checking for $ac_word" >&5
11916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11917 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11918   echo $ECHO_N "(cached) $ECHO_C" >&6
11919 else
11920   if test -n "$WINDMC_FOR_TARGET"; then
11921   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11922 else
11923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11924 for as_dir in $PATH
11925 do
11926   IFS=$as_save_IFS
11927   test -z "$as_dir" && as_dir=.
11928   for ac_exec_ext in '' $ac_executable_extensions; do
11929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11930     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11932     break 2
11933   fi
11934 done
11935 done
11936
11937 fi
11938 fi
11939 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11940 if test -n "$WINDMC_FOR_TARGET"; then
11941   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11942 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11943 else
11944   echo "$as_me:$LINENO: result: no" >&5
11945 echo "${ECHO_T}no" >&6
11946 fi
11947
11948     fi
11949     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11950       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11951 set dummy ${ncn_progname}; ac_word=$2
11952 echo "$as_me:$LINENO: checking for $ac_word" >&5
11953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11954 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11955   echo $ECHO_N "(cached) $ECHO_C" >&6
11956 else
11957   if test -n "$WINDMC_FOR_TARGET"; then
11958   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11959 else
11960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11961 for as_dir in $PATH
11962 do
11963   IFS=$as_save_IFS
11964   test -z "$as_dir" && as_dir=.
11965   for ac_exec_ext in '' $ac_executable_extensions; do
11966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11967     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11969     break 2
11970   fi
11971 done
11972 done
11973
11974 fi
11975 fi
11976 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11977 if test -n "$WINDMC_FOR_TARGET"; then
11978   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11979 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11980 else
11981   echo "$as_me:$LINENO: result: no" >&5
11982 echo "${ECHO_T}no" >&6
11983 fi
11984
11985     fi
11986     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11987   done
11988 fi
11989
11990 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11991   set dummy windmc
11992   if test $build = $target ; then
11993     WINDMC_FOR_TARGET="$2"
11994   else
11995     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11996   fi
11997 else
11998   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11999 fi
12000
12001 else
12002   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
12003 fi
12004
12005
12006 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
12007
12008 echo "$as_me:$LINENO: checking where to find the target ar" >&5
12009 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
12010 if test "x${build}" != "x${host}" ; then
12011   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12012     # We already found the complete path
12013     ac_dir=`dirname $AR_FOR_TARGET`
12014     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12015 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12016   else
12017     # Canadian cross, just use what we found
12018     echo "$as_me:$LINENO: result: pre-installed" >&5
12019 echo "${ECHO_T}pre-installed" >&6
12020   fi
12021 else
12022   ok=yes
12023   case " ${configdirs} " in
12024     *" binutils "*) ;;
12025     *) ok=no ;;
12026   esac
12027
12028   if test $ok = yes; then
12029     # An in-tree tool is available and we can use it
12030     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
12031     echo "$as_me:$LINENO: result: just compiled" >&5
12032 echo "${ECHO_T}just compiled" >&6
12033   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12034     # We already found the complete path
12035     ac_dir=`dirname $AR_FOR_TARGET`
12036     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12037 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12038   elif test "x$target" = "x$host"; then
12039     # We can use an host tool
12040     AR_FOR_TARGET='$(AR)'
12041     echo "$as_me:$LINENO: result: host tool" >&5
12042 echo "${ECHO_T}host tool" >&6
12043   else
12044     # We need a cross tool
12045     echo "$as_me:$LINENO: result: pre-installed" >&5
12046 echo "${ECHO_T}pre-installed" >&6
12047   fi
12048 fi
12049
12050 echo "$as_me:$LINENO: checking where to find the target as" >&5
12051 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
12052 if test "x${build}" != "x${host}" ; then
12053   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12054     # We already found the complete path
12055     ac_dir=`dirname $AS_FOR_TARGET`
12056     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12057 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12058   else
12059     # Canadian cross, just use what we found
12060     echo "$as_me:$LINENO: result: pre-installed" >&5
12061 echo "${ECHO_T}pre-installed" >&6
12062   fi
12063 else
12064   ok=yes
12065   case " ${configdirs} " in
12066     *" gas "*) ;;
12067     *) ok=no ;;
12068   esac
12069
12070   if test $ok = yes; then
12071     # An in-tree tool is available and we can use it
12072     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
12073     echo "$as_me:$LINENO: result: just compiled" >&5
12074 echo "${ECHO_T}just compiled" >&6
12075   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12076     # We already found the complete path
12077     ac_dir=`dirname $AS_FOR_TARGET`
12078     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12079 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12080   elif test "x$target" = "x$host"; then
12081     # We can use an host tool
12082     AS_FOR_TARGET='$(AS)'
12083     echo "$as_me:$LINENO: result: host tool" >&5
12084 echo "${ECHO_T}host tool" >&6
12085   else
12086     # We need a cross tool
12087     echo "$as_me:$LINENO: result: pre-installed" >&5
12088 echo "${ECHO_T}pre-installed" >&6
12089   fi
12090 fi
12091
12092 echo "$as_me:$LINENO: checking where to find the target cc" >&5
12093 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12094 if test "x${build}" != "x${host}" ; then
12095   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12096     # We already found the complete path
12097     ac_dir=`dirname $CC_FOR_TARGET`
12098     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12099 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12100   else
12101     # Canadian cross, just use what we found
12102     echo "$as_me:$LINENO: result: pre-installed" >&5
12103 echo "${ECHO_T}pre-installed" >&6
12104   fi
12105 else
12106   ok=yes
12107   case " ${configdirs} " in
12108     *" gcc "*) ;;
12109     *) ok=no ;;
12110   esac
12111
12112   if test $ok = yes; then
12113     # An in-tree tool is available and we can use it
12114     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12115     echo "$as_me:$LINENO: result: just compiled" >&5
12116 echo "${ECHO_T}just compiled" >&6
12117   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12118     # We already found the complete path
12119     ac_dir=`dirname $CC_FOR_TARGET`
12120     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12121 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12122   elif test "x$target" = "x$host"; then
12123     # We can use an host tool
12124     CC_FOR_TARGET='$(CC)'
12125     echo "$as_me:$LINENO: result: host tool" >&5
12126 echo "${ECHO_T}host tool" >&6
12127   else
12128     # We need a cross tool
12129     echo "$as_me:$LINENO: result: pre-installed" >&5
12130 echo "${ECHO_T}pre-installed" >&6
12131   fi
12132 fi
12133
12134 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12135 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12136 if test "x${build}" != "x${host}" ; then
12137   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12138     # We already found the complete path
12139     ac_dir=`dirname $CXX_FOR_TARGET`
12140     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12141 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12142   else
12143     # Canadian cross, just use what we found
12144     echo "$as_me:$LINENO: result: pre-installed" >&5
12145 echo "${ECHO_T}pre-installed" >&6
12146   fi
12147 else
12148   ok=yes
12149   case " ${configdirs} " in
12150     *" gcc "*) ;;
12151     *) ok=no ;;
12152   esac
12153   case ,${enable_languages}, in
12154     *,c++,*) ;;
12155     *) ok=no ;;
12156   esac
12157   if test $ok = yes; then
12158     # An in-tree tool is available and we can use it
12159     CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/g++ -B$$r/$(HOST_SUBDIR)/gcc/ -nostdinc++ `test ! -f $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags || $(SHELL) $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags --build-includes` -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
12160     echo "$as_me:$LINENO: result: just compiled" >&5
12161 echo "${ECHO_T}just compiled" >&6
12162   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12163     # We already found the complete path
12164     ac_dir=`dirname $CXX_FOR_TARGET`
12165     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12166 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12167   elif test "x$target" = "x$host"; then
12168     # We can use an host tool
12169     CXX_FOR_TARGET='$(CXX)'
12170     echo "$as_me:$LINENO: result: host tool" >&5
12171 echo "${ECHO_T}host tool" >&6
12172   else
12173     # We need a cross tool
12174     echo "$as_me:$LINENO: result: pre-installed" >&5
12175 echo "${ECHO_T}pre-installed" >&6
12176   fi
12177 fi
12178
12179 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12180 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12181 if test "x${build}" != "x${host}" ; then
12182   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12183     # We already found the complete path
12184     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12185     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12186 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12187   else
12188     # Canadian cross, just use what we found
12189     echo "$as_me:$LINENO: result: pre-installed" >&5
12190 echo "${ECHO_T}pre-installed" >&6
12191   fi
12192 else
12193   ok=yes
12194   case " ${configdirs} " in
12195     *" gcc "*) ;;
12196     *) ok=no ;;
12197   esac
12198   case ,${enable_languages}, in
12199     *,c++,*) ;;
12200     *) ok=no ;;
12201   esac
12202   if test $ok = yes; then
12203     # An in-tree tool is available and we can use it
12204     RAW_CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -shared-libgcc -B$$r/$(HOST_SUBDIR)/gcc -nostdinc++ -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
12205     echo "$as_me:$LINENO: result: just compiled" >&5
12206 echo "${ECHO_T}just compiled" >&6
12207   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12208     # We already found the complete path
12209     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12210     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12211 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12212   elif test "x$target" = "x$host"; then
12213     # We can use an host tool
12214     RAW_CXX_FOR_TARGET='$(CXX)'
12215     echo "$as_me:$LINENO: result: host tool" >&5
12216 echo "${ECHO_T}host tool" >&6
12217   else
12218     # We need a cross tool
12219     echo "$as_me:$LINENO: result: pre-installed" >&5
12220 echo "${ECHO_T}pre-installed" >&6
12221   fi
12222 fi
12223
12224 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12225 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12226 if test "x${build}" != "x${host}" ; then
12227   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12228     # We already found the complete path
12229     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12230     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12231 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12232   else
12233     # Canadian cross, just use what we found
12234     echo "$as_me:$LINENO: result: pre-installed" >&5
12235 echo "${ECHO_T}pre-installed" >&6
12236   fi
12237 else
12238   ok=yes
12239   case " ${configdirs} " in
12240     *" binutils "*) ;;
12241     *) ok=no ;;
12242   esac
12243
12244   if test $ok = yes; then
12245     # An in-tree tool is available and we can use it
12246     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12247     echo "$as_me:$LINENO: result: just compiled" >&5
12248 echo "${ECHO_T}just compiled" >&6
12249   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12250     # We already found the complete path
12251     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12252     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12253 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12254   elif test "x$target" = "x$host"; then
12255     # We can use an host tool
12256     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12257     echo "$as_me:$LINENO: result: host tool" >&5
12258 echo "${ECHO_T}host tool" >&6
12259   else
12260     # We need a cross tool
12261     echo "$as_me:$LINENO: result: pre-installed" >&5
12262 echo "${ECHO_T}pre-installed" >&6
12263   fi
12264 fi
12265
12266 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12267 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12268 if test "x${build}" != "x${host}" ; then
12269   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12270     # We already found the complete path
12271     ac_dir=`dirname $GCC_FOR_TARGET`
12272     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12273 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12274   else
12275     # Canadian cross, just use what we found
12276     echo "$as_me:$LINENO: result: pre-installed" >&5
12277 echo "${ECHO_T}pre-installed" >&6
12278   fi
12279 else
12280   ok=yes
12281   case " ${configdirs} " in
12282     *" gcc "*) ;;
12283     *) ok=no ;;
12284   esac
12285
12286   if test $ok = yes; then
12287     # An in-tree tool is available and we can use it
12288     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12289     echo "$as_me:$LINENO: result: just compiled" >&5
12290 echo "${ECHO_T}just compiled" >&6
12291   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12292     # We already found the complete path
12293     ac_dir=`dirname $GCC_FOR_TARGET`
12294     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12295 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12296   elif test "x$target" = "x$host"; then
12297     # We can use an host tool
12298     GCC_FOR_TARGET='$()'
12299     echo "$as_me:$LINENO: result: host tool" >&5
12300 echo "${ECHO_T}host tool" >&6
12301   else
12302     # We need a cross tool
12303     echo "$as_me:$LINENO: result: pre-installed" >&5
12304 echo "${ECHO_T}pre-installed" >&6
12305   fi
12306 fi
12307
12308 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12309 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12310 if test "x${build}" != "x${host}" ; then
12311   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12312     # We already found the complete path
12313     ac_dir=`dirname $GCJ_FOR_TARGET`
12314     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12315 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12316   else
12317     # Canadian cross, just use what we found
12318     echo "$as_me:$LINENO: result: pre-installed" >&5
12319 echo "${ECHO_T}pre-installed" >&6
12320   fi
12321 else
12322   ok=yes
12323   case " ${configdirs} " in
12324     *" gcc "*) ;;
12325     *) ok=no ;;
12326   esac
12327   case ,${enable_languages}, in
12328     *,java,*) ;;
12329     *) ok=no ;;
12330   esac
12331   if test $ok = yes; then
12332     # An in-tree tool is available and we can use it
12333     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12334     echo "$as_me:$LINENO: result: just compiled" >&5
12335 echo "${ECHO_T}just compiled" >&6
12336   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12337     # We already found the complete path
12338     ac_dir=`dirname $GCJ_FOR_TARGET`
12339     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12340 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12341   elif test "x$target" = "x$host"; then
12342     # We can use an host tool
12343     GCJ_FOR_TARGET='$(GCJ)'
12344     echo "$as_me:$LINENO: result: host tool" >&5
12345 echo "${ECHO_T}host tool" >&6
12346   else
12347     # We need a cross tool
12348     echo "$as_me:$LINENO: result: pre-installed" >&5
12349 echo "${ECHO_T}pre-installed" >&6
12350   fi
12351 fi
12352
12353 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12354 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12355 if test "x${build}" != "x${host}" ; then
12356   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12357     # We already found the complete path
12358     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12359     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12360 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12361   else
12362     # Canadian cross, just use what we found
12363     echo "$as_me:$LINENO: result: pre-installed" >&5
12364 echo "${ECHO_T}pre-installed" >&6
12365   fi
12366 else
12367   ok=yes
12368   case " ${configdirs} " in
12369     *" gcc "*) ;;
12370     *) ok=no ;;
12371   esac
12372   case ,${enable_languages}, in
12373     *,fortran,*) ;;
12374     *) ok=no ;;
12375   esac
12376   if test $ok = yes; then
12377     # An in-tree tool is available and we can use it
12378     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12379     echo "$as_me:$LINENO: result: just compiled" >&5
12380 echo "${ECHO_T}just compiled" >&6
12381   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12382     # We already found the complete path
12383     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12384     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12385 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12386   elif test "x$target" = "x$host"; then
12387     # We can use an host tool
12388     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12389     echo "$as_me:$LINENO: result: host tool" >&5
12390 echo "${ECHO_T}host tool" >&6
12391   else
12392     # We need a cross tool
12393     echo "$as_me:$LINENO: result: pre-installed" >&5
12394 echo "${ECHO_T}pre-installed" >&6
12395   fi
12396 fi
12397
12398 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12399 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12400 if test "x${build}" != "x${host}" ; then
12401   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12402     # We already found the complete path
12403     ac_dir=`dirname $LD_FOR_TARGET`
12404     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12405 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12406   else
12407     # Canadian cross, just use what we found
12408     echo "$as_me:$LINENO: result: pre-installed" >&5
12409 echo "${ECHO_T}pre-installed" >&6
12410   fi
12411 else
12412   ok=yes
12413   case " ${configdirs} " in
12414     *" ld "*) ;;
12415     *) ok=no ;;
12416   esac
12417
12418   if test $ok = yes; then
12419     # An in-tree tool is available and we can use it
12420     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12421     echo "$as_me:$LINENO: result: just compiled" >&5
12422 echo "${ECHO_T}just compiled" >&6
12423   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12424     # We already found the complete path
12425     ac_dir=`dirname $LD_FOR_TARGET`
12426     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12427 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12428   elif test "x$target" = "x$host"; then
12429     # We can use an host tool
12430     LD_FOR_TARGET='$(LD)'
12431     echo "$as_me:$LINENO: result: host tool" >&5
12432 echo "${ECHO_T}host tool" >&6
12433   else
12434     # We need a cross tool
12435     echo "$as_me:$LINENO: result: pre-installed" >&5
12436 echo "${ECHO_T}pre-installed" >&6
12437   fi
12438 fi
12439
12440 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12441 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12442 if test "x${build}" != "x${host}" ; then
12443   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12444     # We already found the complete path
12445     ac_dir=`dirname $LIPO_FOR_TARGET`
12446     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12447 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12448   else
12449     # Canadian cross, just use what we found
12450     echo "$as_me:$LINENO: result: pre-installed" >&5
12451 echo "${ECHO_T}pre-installed" >&6
12452   fi
12453 else
12454   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12455     # We already found the complete path
12456     ac_dir=`dirname $LIPO_FOR_TARGET`
12457     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12458 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12459   elif test "x$target" = "x$host"; then
12460     # We can use an host tool
12461     LIPO_FOR_TARGET='$(LIPO)'
12462     echo "$as_me:$LINENO: result: host tool" >&5
12463 echo "${ECHO_T}host tool" >&6
12464   else
12465     # We need a cross tool
12466     echo "$as_me:$LINENO: result: pre-installed" >&5
12467 echo "${ECHO_T}pre-installed" >&6
12468   fi
12469 fi
12470
12471 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12472 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12473 if test "x${build}" != "x${host}" ; then
12474   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12475     # We already found the complete path
12476     ac_dir=`dirname $NM_FOR_TARGET`
12477     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12478 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12479   else
12480     # Canadian cross, just use what we found
12481     echo "$as_me:$LINENO: result: pre-installed" >&5
12482 echo "${ECHO_T}pre-installed" >&6
12483   fi
12484 else
12485   ok=yes
12486   case " ${configdirs} " in
12487     *" binutils "*) ;;
12488     *) ok=no ;;
12489   esac
12490
12491   if test $ok = yes; then
12492     # An in-tree tool is available and we can use it
12493     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12494     echo "$as_me:$LINENO: result: just compiled" >&5
12495 echo "${ECHO_T}just compiled" >&6
12496   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12497     # We already found the complete path
12498     ac_dir=`dirname $NM_FOR_TARGET`
12499     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12500 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12501   elif test "x$target" = "x$host"; then
12502     # We can use an host tool
12503     NM_FOR_TARGET='$(NM)'
12504     echo "$as_me:$LINENO: result: host tool" >&5
12505 echo "${ECHO_T}host tool" >&6
12506   else
12507     # We need a cross tool
12508     echo "$as_me:$LINENO: result: pre-installed" >&5
12509 echo "${ECHO_T}pre-installed" >&6
12510   fi
12511 fi
12512
12513 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12514 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12515 if test "x${build}" != "x${host}" ; then
12516   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12517     # We already found the complete path
12518     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12519     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12520 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12521   else
12522     # Canadian cross, just use what we found
12523     echo "$as_me:$LINENO: result: pre-installed" >&5
12524 echo "${ECHO_T}pre-installed" >&6
12525   fi
12526 else
12527   ok=yes
12528   case " ${configdirs} " in
12529     *" binutils "*) ;;
12530     *) ok=no ;;
12531   esac
12532
12533   if test $ok = yes; then
12534     # An in-tree tool is available and we can use it
12535     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12536     echo "$as_me:$LINENO: result: just compiled" >&5
12537 echo "${ECHO_T}just compiled" >&6
12538   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12539     # We already found the complete path
12540     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12541     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12542 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12543   elif test "x$target" = "x$host"; then
12544     # We can use an host tool
12545     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12546     echo "$as_me:$LINENO: result: host tool" >&5
12547 echo "${ECHO_T}host tool" >&6
12548   else
12549     # We need a cross tool
12550     echo "$as_me:$LINENO: result: pre-installed" >&5
12551 echo "${ECHO_T}pre-installed" >&6
12552   fi
12553 fi
12554
12555 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12556 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12557 if test "x${build}" != "x${host}" ; then
12558   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12559     # We already found the complete path
12560     ac_dir=`dirname $RANLIB_FOR_TARGET`
12561     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12562 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12563   else
12564     # Canadian cross, just use what we found
12565     echo "$as_me:$LINENO: result: pre-installed" >&5
12566 echo "${ECHO_T}pre-installed" >&6
12567   fi
12568 else
12569   ok=yes
12570   case " ${configdirs} " in
12571     *" binutils "*) ;;
12572     *) ok=no ;;
12573   esac
12574
12575   if test $ok = yes; then
12576     # An in-tree tool is available and we can use it
12577     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12578     echo "$as_me:$LINENO: result: just compiled" >&5
12579 echo "${ECHO_T}just compiled" >&6
12580   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12581     # We already found the complete path
12582     ac_dir=`dirname $RANLIB_FOR_TARGET`
12583     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12584 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12585   elif test "x$target" = "x$host"; then
12586     # We can use an host tool
12587     RANLIB_FOR_TARGET='$(RANLIB)'
12588     echo "$as_me:$LINENO: result: host tool" >&5
12589 echo "${ECHO_T}host tool" >&6
12590   else
12591     # We need a cross tool
12592     echo "$as_me:$LINENO: result: pre-installed" >&5
12593 echo "${ECHO_T}pre-installed" >&6
12594   fi
12595 fi
12596
12597 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12598 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12599 if test "x${build}" != "x${host}" ; then
12600   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12601     # We already found the complete path
12602     ac_dir=`dirname $STRIP_FOR_TARGET`
12603     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12604 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12605   else
12606     # Canadian cross, just use what we found
12607     echo "$as_me:$LINENO: result: pre-installed" >&5
12608 echo "${ECHO_T}pre-installed" >&6
12609   fi
12610 else
12611   ok=yes
12612   case " ${configdirs} " in
12613     *" binutils "*) ;;
12614     *) ok=no ;;
12615   esac
12616
12617   if test $ok = yes; then
12618     # An in-tree tool is available and we can use it
12619     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12620     echo "$as_me:$LINENO: result: just compiled" >&5
12621 echo "${ECHO_T}just compiled" >&6
12622   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12623     # We already found the complete path
12624     ac_dir=`dirname $STRIP_FOR_TARGET`
12625     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12626 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12627   elif test "x$target" = "x$host"; then
12628     # We can use an host tool
12629     STRIP_FOR_TARGET='$(STRIP)'
12630     echo "$as_me:$LINENO: result: host tool" >&5
12631 echo "${ECHO_T}host tool" >&6
12632   else
12633     # We need a cross tool
12634     echo "$as_me:$LINENO: result: pre-installed" >&5
12635 echo "${ECHO_T}pre-installed" >&6
12636   fi
12637 fi
12638
12639 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12640 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12641 if test "x${build}" != "x${host}" ; then
12642   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12643     # We already found the complete path
12644     ac_dir=`dirname $WINDRES_FOR_TARGET`
12645     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12646 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12647   else
12648     # Canadian cross, just use what we found
12649     echo "$as_me:$LINENO: result: pre-installed" >&5
12650 echo "${ECHO_T}pre-installed" >&6
12651   fi
12652 else
12653   ok=yes
12654   case " ${configdirs} " in
12655     *" binutils "*) ;;
12656     *) ok=no ;;
12657   esac
12658
12659   if test $ok = yes; then
12660     # An in-tree tool is available and we can use it
12661     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12662     echo "$as_me:$LINENO: result: just compiled" >&5
12663 echo "${ECHO_T}just compiled" >&6
12664   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12665     # We already found the complete path
12666     ac_dir=`dirname $WINDRES_FOR_TARGET`
12667     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12668 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12669   elif test "x$target" = "x$host"; then
12670     # We can use an host tool
12671     WINDRES_FOR_TARGET='$(WINDRES)'
12672     echo "$as_me:$LINENO: result: host tool" >&5
12673 echo "${ECHO_T}host tool" >&6
12674   else
12675     # We need a cross tool
12676     echo "$as_me:$LINENO: result: pre-installed" >&5
12677 echo "${ECHO_T}pre-installed" >&6
12678   fi
12679 fi
12680
12681 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12682 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12683 if test "x${build}" != "x${host}" ; then
12684   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12685     # We already found the complete path
12686     ac_dir=`dirname $WINDMC_FOR_TARGET`
12687     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12688 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12689   else
12690     # Canadian cross, just use what we found
12691     echo "$as_me:$LINENO: result: pre-installed" >&5
12692 echo "${ECHO_T}pre-installed" >&6
12693   fi
12694 else
12695   ok=yes
12696   case " ${configdirs} " in
12697     *" binutils "*) ;;
12698     *) ok=no ;;
12699   esac
12700
12701   if test $ok = yes; then
12702     # An in-tree tool is available and we can use it
12703     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12704     echo "$as_me:$LINENO: result: just compiled" >&5
12705 echo "${ECHO_T}just compiled" >&6
12706   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12707     # We already found the complete path
12708     ac_dir=`dirname $WINDMC_FOR_TARGET`
12709     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12710 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12711   elif test "x$target" = "x$host"; then
12712     # We can use an host tool
12713     WINDMC_FOR_TARGET='$(WINDMC)'
12714     echo "$as_me:$LINENO: result: host tool" >&5
12715 echo "${ECHO_T}host tool" >&6
12716   else
12717     # We need a cross tool
12718     echo "$as_me:$LINENO: result: pre-installed" >&5
12719 echo "${ECHO_T}pre-installed" >&6
12720   fi
12721 fi
12722
12723
12724
12725
12726
12727 # Certain tools may need extra flags.
12728 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12729 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12730 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12731
12732 # When building target libraries, except in a Canadian cross, we use
12733 # the same toolchain as the compiler we just built.
12734 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12735 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12736 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12737 if test $host = $build; then
12738   case " $configdirs " in
12739     *" gcc "*)
12740       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12741       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12742       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12743       ;;
12744   esac
12745 fi
12746
12747
12748
12749
12750
12751 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12752 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12753 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12754 if test "${enable_maintainer_mode+set}" = set; then
12755   enableval="$enable_maintainer_mode"
12756   USE_MAINTAINER_MODE=$enableval
12757 else
12758   USE_MAINTAINER_MODE=no
12759 fi;
12760 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12761 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12762
12763
12764 if test "$USE_MAINTAINER_MODE" = yes; then
12765   MAINTAINER_MODE_TRUE=
12766   MAINTAINER_MODE_FALSE='#'
12767 else
12768   MAINTAINER_MODE_TRUE='#'
12769   MAINTAINER_MODE_FALSE=
12770 fi
12771 MAINT=$MAINTAINER_MODE_TRUE
12772
12773 # ---------------------
12774 # GCC bootstrap support
12775 # ---------------------
12776
12777 # Stage specific cflags for build.
12778 stage1_cflags="-g"
12779 case $build in
12780   vax-*-*)
12781     case ${GCC} in
12782       yes) stage1_cflags="-g -Wa,-J" ;;
12783       *) stage1_cflags="-g -J" ;;
12784     esac ;;
12785 esac
12786
12787 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12788 if test "$GCC" = yes -a "$ENABLE_BUILD_WITH_CXX" != yes; then
12789   saved_CFLAGS="$CFLAGS"
12790
12791   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12792   CFLAGS="$CFLAGS -fkeep-inline-functions"
12793   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12794 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12795   cat >conftest.$ac_ext <<_ACEOF
12796 /* confdefs.h.  */
12797 _ACEOF
12798 cat confdefs.h >>conftest.$ac_ext
12799 cat >>conftest.$ac_ext <<_ACEOF
12800 /* end confdefs.h.  */
12801
12802 #if (__GNUC__ < 3) \
12803     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12804                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12805 #error http://gcc.gnu.org/PR29382
12806 #endif
12807
12808 int
12809 main ()
12810 {
12811
12812   ;
12813   return 0;
12814 }
12815 _ACEOF
12816 rm -f conftest.$ac_objext
12817 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12818   (eval $ac_compile) 2>conftest.er1
12819   ac_status=$?
12820   grep -v '^ *+' conftest.er1 >conftest.err
12821   rm -f conftest.er1
12822   cat conftest.err >&5
12823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12824   (exit $ac_status); } &&
12825          { ac_try='test -z "$ac_c_werror_flag"
12826                          || test ! -s conftest.err'
12827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12828   (eval $ac_try) 2>&5
12829   ac_status=$?
12830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12831   (exit $ac_status); }; } &&
12832          { ac_try='test -s conftest.$ac_objext'
12833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12834   (eval $ac_try) 2>&5
12835   ac_status=$?
12836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12837   (exit $ac_status); }; }; then
12838   echo "$as_me:$LINENO: result: yes" >&5
12839 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12840 else
12841   echo "$as_me: failed program was:" >&5
12842 sed 's/^/| /' conftest.$ac_ext >&5
12843
12844 echo "$as_me:$LINENO: result: no" >&5
12845 echo "${ECHO_T}no" >&6
12846 fi
12847 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12848
12849   CFLAGS="$saved_CFLAGS"
12850 fi
12851
12852
12853
12854 # Enable --enable-checking in stage1 of the compiler.
12855 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12856 if test "${enable_stage1_checking+set}" = set; then
12857   enableval="$enable_stage1_checking"
12858   stage1_checking=--enable-checking=${enable_stage1_checking}
12859 else
12860   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12861   stage1_checking=--enable-checking=yes,types
12862 else
12863   stage1_checking=--enable-checking=$enable_checking,types
12864 fi
12865 fi;
12866
12867
12868 # Enable -Werror in bootstrap stage2 and later.
12869 # Check whether --enable-werror or --disable-werror was given.
12870 if test "${enable_werror+set}" = set; then
12871   enableval="$enable_werror"
12872
12873 else
12874   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12875   enable_werror=yes
12876 else
12877   enable_werror=no
12878 fi
12879 fi;
12880 case ${enable_werror} in
12881   yes) stage2_werror_flag="--enable-werror-always" ;;
12882   *) stage2_werror_flag="" ;;
12883 esac
12884
12885
12886 # Flags needed to enable html installing and building
12887
12888 # Check whether --with-datarootdir or --without-datarootdir was given.
12889 if test "${with_datarootdir+set}" = set; then
12890   withval="$with_datarootdir"
12891   datarootdir="\${prefix}/${withval}"
12892 else
12893   datarootdir="\${prefix}/share"
12894 fi;
12895
12896
12897 # Check whether --with-docdir or --without-docdir was given.
12898 if test "${with_docdir+set}" = set; then
12899   withval="$with_docdir"
12900   docdir="\${prefix}/${withval}"
12901 else
12902   docdir="\${datarootdir}/doc"
12903 fi;
12904
12905
12906 # Check whether --with-pdfdir or --without-pdfdir was given.
12907 if test "${with_pdfdir+set}" = set; then
12908   withval="$with_pdfdir"
12909   pdfdir="\${prefix}/${withval}"
12910 else
12911   pdfdir="\${docdir}"
12912 fi;
12913
12914
12915 # Check whether --with-htmldir or --without-htmldir was given.
12916 if test "${with_htmldir+set}" = set; then
12917   withval="$with_htmldir"
12918   htmldir="\${prefix}/${withval}"
12919 else
12920   htmldir="\${docdir}"
12921 fi;
12922
12923
12924
12925
12926
12927
12928 # Specify what files to not compare during bootstrap.
12929
12930 compare_exclusions="gcc/cc*-checksum\$(objext) | gcc/ada/*tools/*"
12931 case "$target" in
12932   hppa*64*-*-hpux*) ;;
12933   hppa*-*-hpux*) compare_exclusions="gcc/cc*-checksum\$(objext) | */libgcc/lib2funcs* | gcc/ada/*tools/*" ;;
12934 esac
12935
12936
12937           ac_config_files="$ac_config_files Makefile"
12938 cat >confcache <<\_ACEOF
12939 # This file is a shell script that caches the results of configure
12940 # tests run on this system so they can be shared between configure
12941 # scripts and configure runs, see configure's option --config-cache.
12942 # It is not useful on other systems.  If it contains results you don't
12943 # want to keep, you may remove or edit it.
12944 #
12945 # config.status only pays attention to the cache file if you give it
12946 # the --recheck option to rerun configure.
12947 #
12948 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12949 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12950 # following values.
12951
12952 _ACEOF
12953
12954 # The following way of writing the cache mishandles newlines in values,
12955 # but we know of no workaround that is simple, portable, and efficient.
12956 # So, don't put newlines in cache variables' values.
12957 # Ultrix sh set writes to stderr and can't be redirected directly,
12958 # and sets the high bit in the cache file unless we assign to the vars.
12959 {
12960   (set) 2>&1 |
12961     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12962     *ac_space=\ *)
12963       # `set' does not quote correctly, so add quotes (double-quote
12964       # substitution turns \\\\ into \\, and sed turns \\ into \).
12965       sed -n \
12966         "s/'/'\\\\''/g;
12967           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12968       ;;
12969     *)
12970       # `set' quotes correctly as required by POSIX, so do not add quotes.
12971       sed -n \
12972         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12973       ;;
12974     esac;
12975 } |
12976   sed '
12977      t clear
12978      : clear
12979      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12980      t end
12981      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12982      : end' >>confcache
12983 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12984   if test -w $cache_file; then
12985     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12986     cat confcache >$cache_file
12987   else
12988     echo "not updating unwritable cache $cache_file"
12989   fi
12990 fi
12991 rm -f confcache
12992
12993 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12994 # Let make expand exec_prefix.
12995 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12996
12997 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12998 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12999 # trailing colons and then remove the whole line if VPATH becomes empty
13000 # (actually we leave an empty line to preserve line numbers).
13001 if test "x$srcdir" = x.; then
13002   ac_vpsub='/^[  ]*VPATH[        ]*=/{
13003 s/:*\$(srcdir):*/:/;
13004 s/:*\${srcdir}:*/:/;
13005 s/:*@srcdir@:*/:/;
13006 s/^\([^=]*=[     ]*\):*/\1/;
13007 s/:*$//;
13008 s/^[^=]*=[       ]*$//;
13009 }'
13010 fi
13011
13012 # Transform confdefs.h into DEFS.
13013 # Protect against shell expansion while executing Makefile rules.
13014 # Protect against Makefile macro expansion.
13015 #
13016 # If the first sed substitution is executed (which looks for macros that
13017 # take arguments), then we branch to the quote section.  Otherwise,
13018 # look for a macro that doesn't take arguments.
13019 cat >confdef2opt.sed <<\_ACEOF
13020 t clear
13021 : clear
13022 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
13023 t quote
13024 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
13025 t quote
13026 d
13027 : quote
13028 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
13029 s,\[,\\&,g
13030 s,\],\\&,g
13031 s,\$,$$,g
13032 p
13033 _ACEOF
13034 # We use echo to avoid assuming a particular line-breaking character.
13035 # The extra dot is to prevent the shell from consuming trailing
13036 # line-breaks from the sub-command output.  A line-break within
13037 # single-quotes doesn't work because, if this script is created in a
13038 # platform that uses two characters for line-breaks (e.g., DOS), tr
13039 # would break.
13040 ac_LF_and_DOT=`echo; echo .`
13041 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
13042 rm -f confdef2opt.sed
13043
13044
13045 ac_libobjs=
13046 ac_ltlibobjs=
13047 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
13048   # 1. Remove the extension, and $U if already installed.
13049   ac_i=`echo "$ac_i" |
13050          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
13051   # 2. Add them.
13052   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
13053   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
13054 done
13055 LIBOBJS=$ac_libobjs
13056
13057 LTLIBOBJS=$ac_ltlibobjs
13058
13059
13060
13061 : ${CONFIG_STATUS=./config.status}
13062 ac_clean_files_save=$ac_clean_files
13063 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
13064 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
13065 echo "$as_me: creating $CONFIG_STATUS" >&6;}
13066 cat >$CONFIG_STATUS <<_ACEOF
13067 #! $SHELL
13068 # Generated by $as_me.
13069 # Run this file to recreate the current configuration.
13070 # Compiler output produced by configure, useful for debugging
13071 # configure, is in config.log if it exists.
13072
13073 debug=false
13074 ac_cs_recheck=false
13075 ac_cs_silent=false
13076 SHELL=\${CONFIG_SHELL-$SHELL}
13077 _ACEOF
13078
13079 cat >>$CONFIG_STATUS <<\_ACEOF
13080 ## --------------------- ##
13081 ## M4sh Initialization.  ##
13082 ## --------------------- ##
13083
13084 # Be Bourne compatible
13085 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
13086   emulate sh
13087   NULLCMD=:
13088   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
13089   # is contrary to our usage.  Disable this feature.
13090   alias -g '${1+"$@"}'='"$@"'
13091 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
13092   set -o posix
13093 fi
13094 DUALCASE=1; export DUALCASE # for MKS sh
13095
13096 # Support unset when possible.
13097 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13098   as_unset=unset
13099 else
13100   as_unset=false
13101 fi
13102
13103
13104 # Work around bugs in pre-3.0 UWIN ksh.
13105 $as_unset ENV MAIL MAILPATH
13106 PS1='$ '
13107 PS2='> '
13108 PS4='+ '
13109
13110 # NLS nuisances.
13111 for as_var in \
13112   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13113   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13114   LC_TELEPHONE LC_TIME
13115 do
13116   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13117     eval $as_var=C; export $as_var
13118   else
13119     $as_unset $as_var
13120   fi
13121 done
13122
13123 # Required to use basename.
13124 if expr a : '\(a\)' >/dev/null 2>&1; then
13125   as_expr=expr
13126 else
13127   as_expr=false
13128 fi
13129
13130 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13131   as_basename=basename
13132 else
13133   as_basename=false
13134 fi
13135
13136
13137 # Name of the executable.
13138 as_me=`$as_basename "$0" ||
13139 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13140          X"$0" : 'X\(//\)$' \| \
13141          X"$0" : 'X\(/\)$' \| \
13142          .     : '\(.\)' 2>/dev/null ||
13143 echo X/"$0" |
13144     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13145           /^X\/\(\/\/\)$/{ s//\1/; q; }
13146           /^X\/\(\/\).*/{ s//\1/; q; }
13147           s/.*/./; q'`
13148
13149
13150 # PATH needs CR, and LINENO needs CR and PATH.
13151 # Avoid depending upon Character Ranges.
13152 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13153 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13154 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13155 as_cr_digits='0123456789'
13156 as_cr_alnum=$as_cr_Letters$as_cr_digits
13157
13158 # The user is always right.
13159 if test "${PATH_SEPARATOR+set}" != set; then
13160   echo "#! /bin/sh" >conf$$.sh
13161   echo  "exit 0"   >>conf$$.sh
13162   chmod +x conf$$.sh
13163   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13164     PATH_SEPARATOR=';'
13165   else
13166     PATH_SEPARATOR=:
13167   fi
13168   rm -f conf$$.sh
13169 fi
13170
13171
13172   as_lineno_1=$LINENO
13173   as_lineno_2=$LINENO
13174   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13175   test "x$as_lineno_1" != "x$as_lineno_2" &&
13176   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13177   # Find who we are.  Look in the path if we contain no path at all
13178   # relative or not.
13179   case $0 in
13180     *[\\/]* ) as_myself=$0 ;;
13181     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13182 for as_dir in $PATH
13183 do
13184   IFS=$as_save_IFS
13185   test -z "$as_dir" && as_dir=.
13186   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13187 done
13188
13189        ;;
13190   esac
13191   # We did not find ourselves, most probably we were run as `sh COMMAND'
13192   # in which case we are not to be found in the path.
13193   if test "x$as_myself" = x; then
13194     as_myself=$0
13195   fi
13196   if test ! -f "$as_myself"; then
13197     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13198 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13199    { (exit 1); exit 1; }; }
13200   fi
13201   case $CONFIG_SHELL in
13202   '')
13203     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13204 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13205 do
13206   IFS=$as_save_IFS
13207   test -z "$as_dir" && as_dir=.
13208   for as_base in sh bash ksh sh5; do
13209          case $as_dir in
13210          /*)
13211            if ("$as_dir/$as_base" -c '
13212   as_lineno_1=$LINENO
13213   as_lineno_2=$LINENO
13214   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13215   test "x$as_lineno_1" != "x$as_lineno_2" &&
13216   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13217              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13218              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13219              CONFIG_SHELL=$as_dir/$as_base
13220              export CONFIG_SHELL
13221              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13222            fi;;
13223          esac
13224        done
13225 done
13226 ;;
13227   esac
13228
13229   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13230   # uniformly replaced by the line number.  The first 'sed' inserts a
13231   # line-number line before each line; the second 'sed' does the real
13232   # work.  The second script uses 'N' to pair each line-number line
13233   # with the numbered line, and appends trailing '-' during
13234   # substitution so that $LINENO is not a special case at line end.
13235   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13236   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13237   sed '=' <$as_myself |
13238     sed '
13239       N
13240       s,$,-,
13241       : loop
13242       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13243       t loop
13244       s,-$,,
13245       s,^['$as_cr_digits']*\n,,
13246     ' >$as_me.lineno &&
13247   chmod +x $as_me.lineno ||
13248     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13249 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13250    { (exit 1); exit 1; }; }
13251
13252   # Don't try to exec as it changes $[0], causing all sort of problems
13253   # (the dirname of $[0] is not the place where we might find the
13254   # original and so on.  Autoconf is especially sensible to this).
13255   . ./$as_me.lineno
13256   # Exit status is that of the last command.
13257   exit
13258 }
13259
13260
13261 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13262   *c*,-n*) ECHO_N= ECHO_C='
13263 ' ECHO_T='      ' ;;
13264   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13265   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13266 esac
13267
13268 if expr a : '\(a\)' >/dev/null 2>&1; then
13269   as_expr=expr
13270 else
13271   as_expr=false
13272 fi
13273
13274 rm -f conf$$ conf$$.exe conf$$.file
13275 echo >conf$$.file
13276 if ln -s conf$$.file conf$$ 2>/dev/null; then
13277   # We could just check for DJGPP; but this test a) works b) is more generic
13278   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13279   if test -f conf$$.exe; then
13280     # Don't use ln at all; we don't have any links
13281     as_ln_s='cp -p'
13282   else
13283     as_ln_s='ln -s'
13284   fi
13285 elif ln conf$$.file conf$$ 2>/dev/null; then
13286   as_ln_s=ln
13287 else
13288   as_ln_s='cp -p'
13289 fi
13290 rm -f conf$$ conf$$.exe conf$$.file
13291
13292 if mkdir -p . 2>/dev/null; then
13293   as_mkdir_p=:
13294 else
13295   test -d ./-p && rmdir ./-p
13296   as_mkdir_p=false
13297 fi
13298
13299 as_executable_p="test -f"
13300
13301 # Sed expression to map a string onto a valid CPP name.
13302 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13303
13304 # Sed expression to map a string onto a valid variable name.
13305 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13306
13307
13308 # IFS
13309 # We need space, tab and new line, in precisely that order.
13310 as_nl='
13311 '
13312 IFS="   $as_nl"
13313
13314 # CDPATH.
13315 $as_unset CDPATH
13316
13317 exec 6>&1
13318
13319 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13320 # report actual input values of CONFIG_FILES etc. instead of their
13321 # values after options handling.  Logging --version etc. is OK.
13322 exec 5>>config.log
13323 {
13324   echo
13325   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13326 ## Running $as_me. ##
13327 _ASBOX
13328 } >&5
13329 cat >&5 <<_CSEOF
13330
13331 This file was extended by $as_me, which was
13332 generated by GNU Autoconf 2.59.  Invocation command line was
13333
13334   CONFIG_FILES    = $CONFIG_FILES
13335   CONFIG_HEADERS  = $CONFIG_HEADERS
13336   CONFIG_LINKS    = $CONFIG_LINKS
13337   CONFIG_COMMANDS = $CONFIG_COMMANDS
13338   $ $0 $@
13339
13340 _CSEOF
13341 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13342 echo >&5
13343 _ACEOF
13344
13345 # Files that config.status was made for.
13346 if test -n "$ac_config_files"; then
13347   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13348 fi
13349
13350 if test -n "$ac_config_headers"; then
13351   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13352 fi
13353
13354 if test -n "$ac_config_links"; then
13355   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13356 fi
13357
13358 if test -n "$ac_config_commands"; then
13359   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13360 fi
13361
13362 cat >>$CONFIG_STATUS <<\_ACEOF
13363
13364 ac_cs_usage="\
13365 \`$as_me' instantiates files from templates according to the
13366 current configuration.
13367
13368 Usage: $0 [OPTIONS] [FILE]...
13369
13370   -h, --help       print this help, then exit
13371   -V, --version    print version number, then exit
13372   -q, --quiet      do not print progress messages
13373   -d, --debug      don't remove temporary files
13374       --recheck    update $as_me by reconfiguring in the same conditions
13375   --file=FILE[:TEMPLATE]
13376                    instantiate the configuration file FILE
13377
13378 Configuration files:
13379 $config_files
13380
13381 Report bugs to <bug-autoconf@gnu.org>."
13382 _ACEOF
13383
13384 cat >>$CONFIG_STATUS <<_ACEOF
13385 ac_cs_version="\\
13386 config.status
13387 configured by $0, generated by GNU Autoconf 2.59,
13388   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13389
13390 Copyright (C) 2003 Free Software Foundation, Inc.
13391 This config.status script is free software; the Free Software Foundation
13392 gives unlimited permission to copy, distribute and modify it."
13393 srcdir=$srcdir
13394 INSTALL="$INSTALL"
13395 _ACEOF
13396
13397 cat >>$CONFIG_STATUS <<\_ACEOF
13398 # If no file are specified by the user, then we need to provide default
13399 # value.  By we need to know if files were specified by the user.
13400 ac_need_defaults=:
13401 while test $# != 0
13402 do
13403   case $1 in
13404   --*=*)
13405     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13406     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13407     ac_shift=:
13408     ;;
13409   -*)
13410     ac_option=$1
13411     ac_optarg=$2
13412     ac_shift=shift
13413     ;;
13414   *) # This is not an option, so the user has probably given explicit
13415      # arguments.
13416      ac_option=$1
13417      ac_need_defaults=false;;
13418   esac
13419
13420   case $ac_option in
13421   # Handling of the options.
13422 _ACEOF
13423 cat >>$CONFIG_STATUS <<\_ACEOF
13424   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13425     ac_cs_recheck=: ;;
13426   --version | --vers* | -V )
13427     echo "$ac_cs_version"; exit 0 ;;
13428   --he | --h)
13429     # Conflict between --help and --header
13430     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13431 Try \`$0 --help' for more information." >&5
13432 echo "$as_me: error: ambiguous option: $1
13433 Try \`$0 --help' for more information." >&2;}
13434    { (exit 1); exit 1; }; };;
13435   --help | --hel | -h )
13436     echo "$ac_cs_usage"; exit 0 ;;
13437   --debug | --d* | -d )
13438     debug=: ;;
13439   --file | --fil | --fi | --f )
13440     $ac_shift
13441     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13442     ac_need_defaults=false;;
13443   --header | --heade | --head | --hea )
13444     $ac_shift
13445     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13446     ac_need_defaults=false;;
13447   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13448   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13449     ac_cs_silent=: ;;
13450
13451   # This is an error.
13452   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13453 Try \`$0 --help' for more information." >&5
13454 echo "$as_me: error: unrecognized option: $1
13455 Try \`$0 --help' for more information." >&2;}
13456    { (exit 1); exit 1; }; } ;;
13457
13458   *) ac_config_targets="$ac_config_targets $1" ;;
13459
13460   esac
13461   shift
13462 done
13463
13464 ac_configure_extra_args=
13465
13466 if $ac_cs_silent; then
13467   exec 6>/dev/null
13468   ac_configure_extra_args="$ac_configure_extra_args --silent"
13469 fi
13470
13471 _ACEOF
13472 cat >>$CONFIG_STATUS <<_ACEOF
13473 if \$ac_cs_recheck; then
13474   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13475   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13476 fi
13477
13478 _ACEOF
13479
13480
13481
13482
13483
13484 cat >>$CONFIG_STATUS <<\_ACEOF
13485 for ac_config_target in $ac_config_targets
13486 do
13487   case "$ac_config_target" in
13488   # Handling of arguments.
13489   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13490   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13491 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13492    { (exit 1); exit 1; }; };;
13493   esac
13494 done
13495
13496 # If the user did not use the arguments to specify the items to instantiate,
13497 # then the envvar interface is used.  Set only those that are not.
13498 # We use the long form for the default assignment because of an extremely
13499 # bizarre bug on SunOS 4.1.3.
13500 if $ac_need_defaults; then
13501   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13502 fi
13503
13504 # Have a temporary directory for convenience.  Make it in the build tree
13505 # simply because there is no reason to put it here, and in addition,
13506 # creating and moving files from /tmp can sometimes cause problems.
13507 # Create a temporary directory, and hook for its removal unless debugging.
13508 $debug ||
13509 {
13510   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13511   trap '{ (exit 1); exit 1; }' 1 2 13 15
13512 }
13513
13514 # Create a (secure) tmp directory for tmp files.
13515
13516 {
13517   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13518   test -n "$tmp" && test -d "$tmp"
13519 }  ||
13520 {
13521   tmp=./confstat$$-$RANDOM
13522   (umask 077 && mkdir $tmp)
13523 } ||
13524 {
13525    echo "$me: cannot create a temporary directory in ." >&2
13526    { (exit 1); exit 1; }
13527 }
13528
13529 _ACEOF
13530
13531 cat >>$CONFIG_STATUS <<_ACEOF
13532
13533 #
13534 # CONFIG_FILES section.
13535 #
13536
13537 # No need to generate the scripts if there are no CONFIG_FILES.
13538 # This happens for instance when ./config.status config.h
13539 if test -n "\$CONFIG_FILES"; then
13540   # Protect against being on the right side of a sed subst in config.status.
13541   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13542    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13543 s,@SHELL@,$SHELL,;t t
13544 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13545 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13546 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13547 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13548 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13549 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13550 s,@exec_prefix@,$exec_prefix,;t t
13551 s,@prefix@,$prefix,;t t
13552 s,@program_transform_name@,$program_transform_name,;t t
13553 s,@bindir@,$bindir,;t t
13554 s,@sbindir@,$sbindir,;t t
13555 s,@libexecdir@,$libexecdir,;t t
13556 s,@datadir@,$datadir,;t t
13557 s,@sysconfdir@,$sysconfdir,;t t
13558 s,@sharedstatedir@,$sharedstatedir,;t t
13559 s,@localstatedir@,$localstatedir,;t t
13560 s,@libdir@,$libdir,;t t
13561 s,@includedir@,$includedir,;t t
13562 s,@oldincludedir@,$oldincludedir,;t t
13563 s,@infodir@,$infodir,;t t
13564 s,@mandir@,$mandir,;t t
13565 s,@build_alias@,$build_alias,;t t
13566 s,@host_alias@,$host_alias,;t t
13567 s,@target_alias@,$target_alias,;t t
13568 s,@DEFS@,$DEFS,;t t
13569 s,@ECHO_C@,$ECHO_C,;t t
13570 s,@ECHO_N@,$ECHO_N,;t t
13571 s,@ECHO_T@,$ECHO_T,;t t
13572 s,@LIBS@,$LIBS,;t t
13573 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13574 s,@build@,$build,;t t
13575 s,@build_cpu@,$build_cpu,;t t
13576 s,@build_vendor@,$build_vendor,;t t
13577 s,@build_os@,$build_os,;t t
13578 s,@build_noncanonical@,$build_noncanonical,;t t
13579 s,@host_noncanonical@,$host_noncanonical,;t t
13580 s,@target_noncanonical@,$target_noncanonical,;t t
13581 s,@host@,$host,;t t
13582 s,@host_cpu@,$host_cpu,;t t
13583 s,@host_vendor@,$host_vendor,;t t
13584 s,@host_os@,$host_os,;t t
13585 s,@target@,$target,;t t
13586 s,@target_cpu@,$target_cpu,;t t
13587 s,@target_vendor@,$target_vendor,;t t
13588 s,@target_os@,$target_os,;t t
13589 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13590 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13591 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13592 s,@LN@,$LN,;t t
13593 s,@LN_S@,$LN_S,;t t
13594 s,@build_libsubdir@,$build_libsubdir,;t t
13595 s,@build_subdir@,$build_subdir,;t t
13596 s,@host_subdir@,$host_subdir,;t t
13597 s,@target_subdir@,$target_subdir,;t t
13598 s,@CC@,$CC,;t t
13599 s,@CFLAGS@,$CFLAGS,;t t
13600 s,@LDFLAGS@,$LDFLAGS,;t t
13601 s,@CPPFLAGS@,$CPPFLAGS,;t t
13602 s,@ac_ct_CC@,$ac_ct_CC,;t t
13603 s,@EXEEXT@,$EXEEXT,;t t
13604 s,@OBJEXT@,$OBJEXT,;t t
13605 s,@CXX@,$CXX,;t t
13606 s,@CXXFLAGS@,$CXXFLAGS,;t t
13607 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13608 s,@GNATBIND@,$GNATBIND,;t t
13609 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13610 s,@GNATMAKE@,$GNATMAKE,;t t
13611 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13612 s,@do_compare@,$do_compare,;t t
13613 s,@gmplibs@,$gmplibs,;t t
13614 s,@gmpinc@,$gmpinc,;t t
13615 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13616 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13617 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13618 s,@stage1_ldflags@,$stage1_ldflags,;t t
13619 s,@stage1_libs@,$stage1_libs,;t t
13620 s,@poststage1_ldflags@,$poststage1_ldflags,;t t
13621 s,@poststage1_libs@,$poststage1_libs,;t t
13622 s,@ppllibs@,$ppllibs,;t t
13623 s,@pplinc@,$pplinc,;t t
13624 s,@clooglibs@,$clooglibs,;t t
13625 s,@clooginc@,$clooginc,;t t
13626 s,@stage1_languages@,$stage1_languages,;t t
13627 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13628 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13629 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13630 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13631 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13632 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13633 s,@tooldir@,$tooldir,;t t
13634 s,@build_tooldir@,$build_tooldir,;t t
13635 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13636 s,@GDB_TK@,$GDB_TK,;t t
13637 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13638 s,@build_configargs@,$build_configargs,;t t
13639 s,@build_configdirs@,$build_configdirs,;t t
13640 s,@host_configargs@,$host_configargs,;t t
13641 s,@configdirs@,$configdirs,;t t
13642 s,@target_configargs@,$target_configargs,;t t
13643 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13644 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13645 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13646 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13647 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13648 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13649 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13650 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13651 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13652 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13653 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13654 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13655 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13656 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13657 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13658 s,@config_shell@,$config_shell,;t t
13659 s,@YACC@,$YACC,;t t
13660 s,@BISON@,$BISON,;t t
13661 s,@M4@,$M4,;t t
13662 s,@LEX@,$LEX,;t t
13663 s,@FLEX@,$FLEX,;t t
13664 s,@MAKEINFO@,$MAKEINFO,;t t
13665 s,@EXPECT@,$EXPECT,;t t
13666 s,@RUNTEST@,$RUNTEST,;t t
13667 s,@AR@,$AR,;t t
13668 s,@AS@,$AS,;t t
13669 s,@DLLTOOL@,$DLLTOOL,;t t
13670 s,@LD@,$LD,;t t
13671 s,@LIPO@,$LIPO,;t t
13672 s,@NM@,$NM,;t t
13673 s,@RANLIB@,$RANLIB,;t t
13674 s,@STRIP@,$STRIP,;t t
13675 s,@WINDRES@,$WINDRES,;t t
13676 s,@WINDMC@,$WINDMC,;t t
13677 s,@OBJCOPY@,$OBJCOPY,;t t
13678 s,@OBJDUMP@,$OBJDUMP,;t t
13679 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13680 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13681 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13682 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13683 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13684 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13685 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13686 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13687 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13688 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13689 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13690 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13691 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13692 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13693 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13694 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13695 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13696 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13697 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13698 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13699 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13700 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13701 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13702 s,@MAINT@,$MAINT,;t t
13703 s,@stage1_cflags@,$stage1_cflags,;t t
13704 s,@stage1_checking@,$stage1_checking,;t t
13705 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13706 s,@datarootdir@,$datarootdir,;t t
13707 s,@docdir@,$docdir,;t t
13708 s,@pdfdir@,$pdfdir,;t t
13709 s,@htmldir@,$htmldir,;t t
13710 s,@compare_exclusions@,$compare_exclusions,;t t
13711 s,@LIBOBJS@,$LIBOBJS,;t t
13712 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13713 /@serialization_dependencies@/r $serialization_dependencies
13714 s,@serialization_dependencies@,,;t t
13715 /@host_makefile_frag@/r $host_makefile_frag
13716 s,@host_makefile_frag@,,;t t
13717 /@target_makefile_frag@/r $target_makefile_frag
13718 s,@target_makefile_frag@,,;t t
13719 /@alphaieee_frag@/r $alphaieee_frag
13720 s,@alphaieee_frag@,,;t t
13721 /@ospace_frag@/r $ospace_frag
13722 s,@ospace_frag@,,;t t
13723 CEOF
13724
13725 _ACEOF
13726
13727   cat >>$CONFIG_STATUS <<\_ACEOF
13728   # Split the substitutions into bite-sized pieces for seds with
13729   # small command number limits, like on Digital OSF/1 and HP-UX.
13730   ac_max_sed_lines=48
13731   ac_sed_frag=1 # Number of current file.
13732   ac_beg=1 # First line for current file.
13733   ac_end=$ac_max_sed_lines # Line after last line for current file.
13734   ac_more_lines=:
13735   ac_sed_cmds=
13736   while $ac_more_lines; do
13737     if test $ac_beg -gt 1; then
13738       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13739     else
13740       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13741     fi
13742     if test ! -s $tmp/subs.frag; then
13743       ac_more_lines=false
13744     else
13745       # The purpose of the label and of the branching condition is to
13746       # speed up the sed processing (if there are no `@' at all, there
13747       # is no need to browse any of the substitutions).
13748       # These are the two extra sed commands mentioned above.
13749       (echo ':t
13750   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13751       if test -z "$ac_sed_cmds"; then
13752         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13753       else
13754         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13755       fi
13756       ac_sed_frag=`expr $ac_sed_frag + 1`
13757       ac_beg=$ac_end
13758       ac_end=`expr $ac_end + $ac_max_sed_lines`
13759     fi
13760   done
13761   if test -z "$ac_sed_cmds"; then
13762     ac_sed_cmds=cat
13763   fi
13764 fi # test -n "$CONFIG_FILES"
13765
13766 _ACEOF
13767 cat >>$CONFIG_STATUS <<\_ACEOF
13768 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13769   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13770   case $ac_file in
13771   - | *:- | *:-:* ) # input from stdin
13772         cat >$tmp/stdin
13773         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13774         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13775   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13776         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13777   * )   ac_file_in=$ac_file.in ;;
13778   esac
13779
13780   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13781   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13782 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13783          X"$ac_file" : 'X\(//\)[^/]' \| \
13784          X"$ac_file" : 'X\(//\)$' \| \
13785          X"$ac_file" : 'X\(/\)' \| \
13786          .     : '\(.\)' 2>/dev/null ||
13787 echo X"$ac_file" |
13788     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13789           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13790           /^X\(\/\/\)$/{ s//\1/; q; }
13791           /^X\(\/\).*/{ s//\1/; q; }
13792           s/.*/./; q'`
13793   { if $as_mkdir_p; then
13794     mkdir -p "$ac_dir"
13795   else
13796     as_dir="$ac_dir"
13797     as_dirs=
13798     while test ! -d "$as_dir"; do
13799       as_dirs="$as_dir $as_dirs"
13800       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13801 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13802          X"$as_dir" : 'X\(//\)[^/]' \| \
13803          X"$as_dir" : 'X\(//\)$' \| \
13804          X"$as_dir" : 'X\(/\)' \| \
13805          .     : '\(.\)' 2>/dev/null ||
13806 echo X"$as_dir" |
13807     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13808           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13809           /^X\(\/\/\)$/{ s//\1/; q; }
13810           /^X\(\/\).*/{ s//\1/; q; }
13811           s/.*/./; q'`
13812     done
13813     test ! -n "$as_dirs" || mkdir $as_dirs
13814   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13815 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13816    { (exit 1); exit 1; }; }; }
13817
13818   ac_builddir=.
13819
13820 if test "$ac_dir" != .; then
13821   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13822   # A "../" for each directory in $ac_dir_suffix.
13823   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13824 else
13825   ac_dir_suffix= ac_top_builddir=
13826 fi
13827
13828 case $srcdir in
13829   .)  # No --srcdir option.  We are building in place.
13830     ac_srcdir=.
13831     if test -z "$ac_top_builddir"; then
13832        ac_top_srcdir=.
13833     else
13834        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13835     fi ;;
13836   [\\/]* | ?:[\\/]* )  # Absolute path.
13837     ac_srcdir=$srcdir$ac_dir_suffix;
13838     ac_top_srcdir=$srcdir ;;
13839   *) # Relative path.
13840     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13841     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13842 esac
13843
13844 # Do not use `cd foo && pwd` to compute absolute paths, because
13845 # the directories may not exist.
13846 case `pwd` in
13847 .) ac_abs_builddir="$ac_dir";;
13848 *)
13849   case "$ac_dir" in
13850   .) ac_abs_builddir=`pwd`;;
13851   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13852   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13853   esac;;
13854 esac
13855 case $ac_abs_builddir in
13856 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13857 *)
13858   case ${ac_top_builddir}. in
13859   .) ac_abs_top_builddir=$ac_abs_builddir;;
13860   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13861   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13862   esac;;
13863 esac
13864 case $ac_abs_builddir in
13865 .) ac_abs_srcdir=$ac_srcdir;;
13866 *)
13867   case $ac_srcdir in
13868   .) ac_abs_srcdir=$ac_abs_builddir;;
13869   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13870   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13871   esac;;
13872 esac
13873 case $ac_abs_builddir in
13874 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13875 *)
13876   case $ac_top_srcdir in
13877   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13878   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13879   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13880   esac;;
13881 esac
13882
13883
13884   case $INSTALL in
13885   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13886   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13887   esac
13888
13889   if test x"$ac_file" != x-; then
13890     { echo "$as_me:$LINENO: creating $ac_file" >&5
13891 echo "$as_me: creating $ac_file" >&6;}
13892     rm -f "$ac_file"
13893   fi
13894   # Let's still pretend it is `configure' which instantiates (i.e., don't
13895   # use $as_me), people would be surprised to read:
13896   #    /* config.h.  Generated by config.status.  */
13897   if test x"$ac_file" = x-; then
13898     configure_input=
13899   else
13900     configure_input="$ac_file.  "
13901   fi
13902   configure_input=$configure_input"Generated from `echo $ac_file_in |
13903                                      sed 's,.*/,,'` by configure."
13904
13905   # First look for the input files in the build tree, otherwise in the
13906   # src tree.
13907   ac_file_inputs=`IFS=:
13908     for f in $ac_file_in; do
13909       case $f in
13910       -) echo $tmp/stdin ;;
13911       [\\/$]*)
13912          # Absolute (can't be DOS-style, as IFS=:)
13913          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13914 echo "$as_me: error: cannot find input file: $f" >&2;}
13915    { (exit 1); exit 1; }; }
13916          echo "$f";;
13917       *) # Relative
13918          if test -f "$f"; then
13919            # Build tree
13920            echo "$f"
13921          elif test -f "$srcdir/$f"; then
13922            # Source tree
13923            echo "$srcdir/$f"
13924          else
13925            # /dev/null tree
13926            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13927 echo "$as_me: error: cannot find input file: $f" >&2;}
13928    { (exit 1); exit 1; }; }
13929          fi;;
13930       esac
13931     done` || { (exit 1); exit 1; }
13932 _ACEOF
13933 cat >>$CONFIG_STATUS <<_ACEOF
13934   sed "$ac_vpsub
13935 $extrasub
13936 _ACEOF
13937 cat >>$CONFIG_STATUS <<\_ACEOF
13938 :t
13939 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13940 s,@configure_input@,$configure_input,;t t
13941 s,@srcdir@,$ac_srcdir,;t t
13942 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13943 s,@top_srcdir@,$ac_top_srcdir,;t t
13944 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13945 s,@builddir@,$ac_builddir,;t t
13946 s,@abs_builddir@,$ac_abs_builddir,;t t
13947 s,@top_builddir@,$ac_top_builddir,;t t
13948 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13949 s,@INSTALL@,$ac_INSTALL,;t t
13950 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13951   rm -f $tmp/stdin
13952   if test x"$ac_file" != x-; then
13953     mv $tmp/out $ac_file
13954   else
13955     cat $tmp/out
13956     rm -f $tmp/out
13957   fi
13958
13959 done
13960 _ACEOF
13961
13962 cat >>$CONFIG_STATUS <<\_ACEOF
13963
13964 { (exit 0); exit 0; }
13965 _ACEOF
13966 chmod +x $CONFIG_STATUS
13967 ac_clean_files=$ac_clean_files_save
13968
13969
13970 # configure is writing to config.log, and then calls config.status.
13971 # config.status does its own redirection, appending to config.log.
13972 # Unfortunately, on DOS this fails, as config.log is still kept open
13973 # by configure, so config.status won't be able to write to it; its
13974 # output is simply discarded.  So we exec the FD to /dev/null,
13975 # effectively closing config.log, so it can be properly (re)opened and
13976 # appended to by config.status.  When coming back to configure, we
13977 # need to make the FD available again.
13978 if test "$no_create" != yes; then
13979   ac_cs_success=:
13980   ac_config_status_args=
13981   test "$silent" = yes &&
13982     ac_config_status_args="$ac_config_status_args --quiet"
13983   exec 5>/dev/null
13984   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13985   exec 5>>config.log
13986   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13987   # would make configure fail if this is the last instruction.
13988   $ac_cs_success || { (exit 1); exit 1; }
13989 fi
13990