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   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 986                           Equivalent to --with-ppl-include=PATH/include
 987                           plus --with-ppl-lib=PATH/lib
 988   --with-ppl-include=PATH Specify directory for installed PPL include files
 989   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 990   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 991                           Equivalent to --with-cloog-include=PATH/include
 992                           plus --with-cloog-lib=PATH/lib
 993   --with-cloog-include=PATH Specify directory for installed CLooG include files
 994   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 995   --with-build-sysroot=SYSROOT
 996                           use sysroot as the system root during the build
 997   --with-debug-prefix-map='A=B C=D ...'
 998                              map A to B, C to D ... in debug information
 999   --with-build-time-tools=PATH
1000                           use given path to find target tools during the build
1001   --with-datarootdir      use datarootdir as the data root directory.
1002   --with-docdir           install documentation in this directory.
1003   --with-pdfdir           install pdf in this directory.
1004   --with-htmldir          install html in this directory.
1005
1006 Some influential environment variables:
1007   CC          C compiler command
1008   CFLAGS      C compiler flags
1009   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1010               nonstandard directory <lib dir>
1011   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1012               headers in a nonstandard directory <include dir>
1013   CXX         C++ compiler command
1014   CXXFLAGS    C++ compiler flags
1015   AR          AR for the host
1016   AS          AS for the host
1017   DLLTOOL     DLLTOOL for the host
1018   LD          LD for the host
1019   LIPO        LIPO for the host
1020   NM          NM for the host
1021   RANLIB      RANLIB for the host
1022   STRIP       STRIP for the host
1023   WINDRES     WINDRES for the host
1024   WINDMC      WINDMC for the host
1025   OBJCOPY     OBJCOPY for the host
1026   OBJDUMP     OBJDUMP for the host
1027   CC_FOR_TARGET
1028               CC for the target
1029   CXX_FOR_TARGET
1030               CXX for the target
1031   GCC_FOR_TARGET
1032               GCC for the target
1033   GCJ_FOR_TARGET
1034               GCJ for the target
1035   GFORTRAN_FOR_TARGET
1036               GFORTRAN for the target
1037   AR_FOR_TARGET
1038               AR for the target
1039   AS_FOR_TARGET
1040               AS for the target
1041   DLLTOOL_FOR_TARGET
1042               DLLTOOL for the target
1043   LD_FOR_TARGET
1044               LD for the target
1045   LIPO_FOR_TARGET
1046               LIPO for the target
1047   NM_FOR_TARGET
1048               NM for the target
1049   OBJDUMP_FOR_TARGET
1050               OBJDUMP for the target
1051   RANLIB_FOR_TARGET
1052               RANLIB for the target
1053   STRIP_FOR_TARGET
1054               STRIP for the target
1055   WINDRES_FOR_TARGET
1056               WINDRES for the target
1057   WINDMC_FOR_TARGET
1058               WINDMC for the target
1059
1060 Use these variables to override the choices made by `configure' or to help
1061 it to find libraries and programs with nonstandard names/locations.
1062
1063 _ACEOF
1064 fi
1065
1066 if test "$ac_init_help" = "recursive"; then
1067   # If there are subdirs, report their specific --help.
1068   ac_popdir=`pwd`
1069   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1070     test -d $ac_dir || continue
1071     ac_builddir=.
1072
1073 if test "$ac_dir" != .; then
1074   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1075   # A "../" for each directory in $ac_dir_suffix.
1076   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1077 else
1078   ac_dir_suffix= ac_top_builddir=
1079 fi
1080
1081 case $srcdir in
1082   .)  # No --srcdir option.  We are building in place.
1083     ac_srcdir=.
1084     if test -z "$ac_top_builddir"; then
1085        ac_top_srcdir=.
1086     else
1087        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1088     fi ;;
1089   [\\/]* | ?:[\\/]* )  # Absolute path.
1090     ac_srcdir=$srcdir$ac_dir_suffix;
1091     ac_top_srcdir=$srcdir ;;
1092   *) # Relative path.
1093     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1094     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1095 esac
1096
1097 # Do not use `cd foo && pwd` to compute absolute paths, because
1098 # the directories may not exist.
1099 case `pwd` in
1100 .) ac_abs_builddir="$ac_dir";;
1101 *)
1102   case "$ac_dir" in
1103   .) ac_abs_builddir=`pwd`;;
1104   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1105   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1106   esac;;
1107 esac
1108 case $ac_abs_builddir in
1109 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1110 *)
1111   case ${ac_top_builddir}. in
1112   .) ac_abs_top_builddir=$ac_abs_builddir;;
1113   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1114   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1115   esac;;
1116 esac
1117 case $ac_abs_builddir in
1118 .) ac_abs_srcdir=$ac_srcdir;;
1119 *)
1120   case $ac_srcdir in
1121   .) ac_abs_srcdir=$ac_abs_builddir;;
1122   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1123   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1124   esac;;
1125 esac
1126 case $ac_abs_builddir in
1127 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1128 *)
1129   case $ac_top_srcdir in
1130   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1131   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1132   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1133   esac;;
1134 esac
1135
1136     cd $ac_dir
1137     # Check for guested configure; otherwise get Cygnus style configure.
1138     if test -f $ac_srcdir/configure.gnu; then
1139       echo
1140       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1141     elif test -f $ac_srcdir/configure; then
1142       echo
1143       $SHELL $ac_srcdir/configure  --help=recursive
1144     elif test -f $ac_srcdir/configure.ac ||
1145            test -f $ac_srcdir/configure.in; then
1146       echo
1147       $ac_configure --help
1148     else
1149       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1150     fi
1151     cd $ac_popdir
1152   done
1153 fi
1154
1155 test -n "$ac_init_help" && exit 0
1156 if $ac_init_version; then
1157   cat <<\_ACEOF
1158
1159 Copyright (C) 2003 Free Software Foundation, Inc.
1160 This configure script is free software; the Free Software Foundation
1161 gives unlimited permission to copy, distribute and modify it.
1162 _ACEOF
1163   exit 0
1164 fi
1165 exec 5>config.log
1166 cat >&5 <<_ACEOF
1167 This file contains any messages produced by compilers while
1168 running configure, to aid debugging if configure makes a mistake.
1169
1170 It was created by $as_me, which was
1171 generated by GNU Autoconf 2.59.  Invocation command line was
1172
1173   $ $0 $@
1174
1175 _ACEOF
1176 {
1177 cat <<_ASUNAME
1178 ## --------- ##
1179 ## Platform. ##
1180 ## --------- ##
1181
1182 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1183 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1184 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1185 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1186 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1187
1188 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1189 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1190
1191 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1192 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1193 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1194 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1195 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1196 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1197 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1198
1199 _ASUNAME
1200
1201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1202 for as_dir in $PATH
1203 do
1204   IFS=$as_save_IFS
1205   test -z "$as_dir" && as_dir=.
1206   echo "PATH: $as_dir"
1207 done
1208
1209 } >&5
1210
1211 cat >&5 <<_ACEOF
1212
1213
1214 ## ----------- ##
1215 ## Core tests. ##
1216 ## ----------- ##
1217
1218 _ACEOF
1219
1220
1221 # Keep a trace of the command line.
1222 # Strip out --no-create and --no-recursion so they do not pile up.
1223 # Strip out --silent because we don't want to record it for future runs.
1224 # Also quote any args containing shell meta-characters.
1225 # Make two passes to allow for proper duplicate-argument suppression.
1226 ac_configure_args=
1227 ac_configure_args0=
1228 ac_configure_args1=
1229 ac_sep=
1230 ac_must_keep_next=false
1231 for ac_pass in 1 2
1232 do
1233   for ac_arg
1234   do
1235     case $ac_arg in
1236     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1237     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1238     | -silent | --silent | --silen | --sile | --sil)
1239       continue ;;
1240     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1241       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1242     esac
1243     case $ac_pass in
1244     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1245     2)
1246       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1247       if test $ac_must_keep_next = true; then
1248         ac_must_keep_next=false # Got value, back to normal.
1249       else
1250         case $ac_arg in
1251           *=* | --config-cache | -C | -disable-* | --disable-* \
1252           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1253           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1254           | -with-* | --with-* | -without-* | --without-* | --x)
1255             case "$ac_configure_args0 " in
1256               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1257             esac
1258             ;;
1259           -* ) ac_must_keep_next=true ;;
1260         esac
1261       fi
1262       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1263       # Get rid of the leading space.
1264       ac_sep=" "
1265       ;;
1266     esac
1267   done
1268 done
1269 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1270 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1271
1272 # When interrupted or exit'd, cleanup temporary files, and complete
1273 # config.log.  We remove comments because anyway the quotes in there
1274 # would cause problems or look ugly.
1275 # WARNING: Be sure not to use single quotes in there, as some shells,
1276 # such as our DU 5.0 friend, will then `close' the trap.
1277 trap 'exit_status=$?
1278   # Save into config.log some information that might help in debugging.
1279   {
1280     echo
1281
1282     cat <<\_ASBOX
1283 ## ---------------- ##
1284 ## Cache variables. ##
1285 ## ---------------- ##
1286 _ASBOX
1287     echo
1288     # The following way of writing the cache mishandles newlines in values,
1289 {
1290   (set) 2>&1 |
1291     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1292     *ac_space=\ *)
1293       sed -n \
1294         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1295           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1296       ;;
1297     *)
1298       sed -n \
1299         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1300       ;;
1301     esac;
1302 }
1303     echo
1304
1305     cat <<\_ASBOX
1306 ## ----------------- ##
1307 ## Output variables. ##
1308 ## ----------------- ##
1309 _ASBOX
1310     echo
1311     for ac_var in $ac_subst_vars
1312     do
1313       eval ac_val=$`echo $ac_var`
1314       echo "$ac_var='"'"'$ac_val'"'"'"
1315     done | sort
1316     echo
1317
1318     if test -n "$ac_subst_files"; then
1319       cat <<\_ASBOX
1320 ## ------------- ##
1321 ## Output files. ##
1322 ## ------------- ##
1323 _ASBOX
1324       echo
1325       for ac_var in $ac_subst_files
1326       do
1327         eval ac_val=$`echo $ac_var`
1328         echo "$ac_var='"'"'$ac_val'"'"'"
1329       done | sort
1330       echo
1331     fi
1332
1333     if test -s confdefs.h; then
1334       cat <<\_ASBOX
1335 ## ----------- ##
1336 ## confdefs.h. ##
1337 ## ----------- ##
1338 _ASBOX
1339       echo
1340       sed "/^$/d" confdefs.h | sort
1341       echo
1342     fi
1343     test "$ac_signal" != 0 &&
1344       echo "$as_me: caught signal $ac_signal"
1345     echo "$as_me: exit $exit_status"
1346   } >&5
1347   rm -f core *.core &&
1348   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1349     exit $exit_status
1350      ' 0
1351 for ac_signal in 1 2 13 15; do
1352   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1353 done
1354 ac_signal=0
1355
1356 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1357 rm -rf conftest* confdefs.h
1358 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1359 echo >confdefs.h
1360
1361 # Predefined preprocessor variables.
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_NAME "$PACKAGE_NAME"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_STRING "$PACKAGE_STRING"
1380 _ACEOF
1381
1382
1383 cat >>confdefs.h <<_ACEOF
1384 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1385 _ACEOF
1386
1387
1388 # Let the site file select an alternate cache file if it wants to.
1389 # Prefer explicitly selected file to automatically selected ones.
1390 if test -z "$CONFIG_SITE"; then
1391   if test "x$prefix" != xNONE; then
1392     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1393   else
1394     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1395   fi
1396 fi
1397 for ac_site_file in $CONFIG_SITE; do
1398   if test -r "$ac_site_file"; then
1399     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1400 echo "$as_me: loading site script $ac_site_file" >&6;}
1401     sed 's/^/| /' "$ac_site_file" >&5
1402     . "$ac_site_file"
1403   fi
1404 done
1405
1406 if test -r "$cache_file"; then
1407   # Some versions of bash will fail to source /dev/null (special
1408   # files actually), so we avoid doing that.
1409   if test -f "$cache_file"; then
1410     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1411 echo "$as_me: loading cache $cache_file" >&6;}
1412     case $cache_file in
1413       [\\/]* | ?:[\\/]* ) . $cache_file;;
1414       *)                      . ./$cache_file;;
1415     esac
1416   fi
1417 else
1418   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1419 echo "$as_me: creating cache $cache_file" >&6;}
1420   >$cache_file
1421 fi
1422
1423 # Check that the precious variables saved in the cache have kept the same
1424 # value.
1425 ac_cache_corrupted=false
1426 for ac_var in `(set) 2>&1 |
1427                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1428   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1429   eval ac_new_set=\$ac_env_${ac_var}_set
1430   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1431   eval ac_new_val="\$ac_env_${ac_var}_value"
1432   case $ac_old_set,$ac_new_set in
1433     set,)
1434       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1435 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1436       ac_cache_corrupted=: ;;
1437     ,set)
1438       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1439 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1440       ac_cache_corrupted=: ;;
1441     ,);;
1442     *)
1443       if test "x$ac_old_val" != "x$ac_new_val"; then
1444         # differences in whitespace do not lead to failure.
1445         ac_old_val_w=`echo x $ac_old_val`
1446         ac_new_val_w=`echo x $ac_new_val`
1447         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1448           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1449 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1450           ac_cache_corrupted=:
1451         else
1452           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1453 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1454           eval $ac_var=\$ac_old_val
1455         fi
1456         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1457 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1458         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1459 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1460       fi;;
1461   esac
1462   # Pass precious variables to config.status.
1463   if test "$ac_new_set" = set; then
1464     case $ac_new_val in
1465     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1466       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1467     *) ac_arg=$ac_var=$ac_new_val ;;
1468     esac
1469     case " $ac_configure_args " in
1470       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1471       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1472     esac
1473   fi
1474 done
1475 if $ac_cache_corrupted; then
1476   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1477 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1478   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1479 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1480   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1481 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1482    { (exit 1); exit 1; }; }
1483 fi
1484
1485 ac_ext=c
1486 ac_cpp='$CPP $CPPFLAGS'
1487 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1488 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1489 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514 progname=$0
1515 # if PWD already has a value, it is probably wrong.
1516 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1517
1518 # Export original configure arguments for use by sub-configures.
1519 # Quote arguments with shell meta charatcers.
1520 TOPLEVEL_CONFIGURE_ARGUMENTS=
1521 set -- "$progname" "$@"
1522 for ac_arg
1523 do
1524   case "$ac_arg" in
1525   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1526     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1527     # if the argument is of the form -foo=baz, quote the baz part only
1528     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1529   *) ;;
1530   esac
1531   # Add the quoted argument to the list.
1532   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1533 done
1534 if test "$silent" = yes; then
1535   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1536 fi
1537 # Remove the initial space we just introduced and, as these will be
1538 # expanded by make, quote '$'.
1539 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1540
1541
1542 # Find the build, host, and target systems.
1543 ac_aux_dir=
1544 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1545   if test -f $ac_dir/install-sh; then
1546     ac_aux_dir=$ac_dir
1547     ac_install_sh="$ac_aux_dir/install-sh -c"
1548     break
1549   elif test -f $ac_dir/install.sh; then
1550     ac_aux_dir=$ac_dir
1551     ac_install_sh="$ac_aux_dir/install.sh -c"
1552     break
1553   elif test -f $ac_dir/shtool; then
1554     ac_aux_dir=$ac_dir
1555     ac_install_sh="$ac_aux_dir/shtool install -c"
1556     break
1557   fi
1558 done
1559 if test -z "$ac_aux_dir"; then
1560   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1561 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1562    { (exit 1); exit 1; }; }
1563 fi
1564 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1565 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1566 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1567
1568 # Make sure we can run config.sub.
1569 $ac_config_sub sun4 >/dev/null 2>&1 ||
1570   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1571 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1572    { (exit 1); exit 1; }; }
1573
1574 echo "$as_me:$LINENO: checking build system type" >&5
1575 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1576 if test "${ac_cv_build+set}" = set; then
1577   echo $ECHO_N "(cached) $ECHO_C" >&6
1578 else
1579   ac_cv_build_alias=$build_alias
1580 test -z "$ac_cv_build_alias" &&
1581   ac_cv_build_alias=`$ac_config_guess`
1582 test -z "$ac_cv_build_alias" &&
1583   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1584 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1585    { (exit 1); exit 1; }; }
1586 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1593 echo "${ECHO_T}$ac_cv_build" >&6
1594 build=$ac_cv_build
1595 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600  case ${build_alias} in
1601   "") build_noncanonical=${build} ;;
1602   *) build_noncanonical=${build_alias} ;;
1603 esac
1604
1605
1606
1607  case ${host_alias} in
1608   "") host_noncanonical=${build_noncanonical} ;;
1609   *) host_noncanonical=${host_alias} ;;
1610 esac
1611
1612
1613
1614  case ${target_alias} in
1615   "") target_noncanonical=${host_noncanonical} ;;
1616   *) target_noncanonical=${target_alias} ;;
1617 esac
1618
1619
1620
1621
1622 test "$host_noncanonical" = "$target_noncanonical" &&
1623   test "$program_prefix$program_suffix$program_transform_name" = \
1624     NONENONEs,x,x, &&
1625   program_transform_name=s,y,y,
1626
1627 echo "$as_me:$LINENO: checking host system type" >&5
1628 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1629 if test "${ac_cv_host+set}" = set; then
1630   echo $ECHO_N "(cached) $ECHO_C" >&6
1631 else
1632   ac_cv_host_alias=$host_alias
1633 test -z "$ac_cv_host_alias" &&
1634   ac_cv_host_alias=$ac_cv_build_alias
1635 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1636   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1637 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1638    { (exit 1); exit 1; }; }
1639
1640 fi
1641 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1642 echo "${ECHO_T}$ac_cv_host" >&6
1643 host=$ac_cv_host
1644 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1645 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1646 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1647
1648
1649 echo "$as_me:$LINENO: checking target system type" >&5
1650 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1651 if test "${ac_cv_target+set}" = set; then
1652   echo $ECHO_N "(cached) $ECHO_C" >&6
1653 else
1654   ac_cv_target_alias=$target_alias
1655 test "x$ac_cv_target_alias" = "x" &&
1656   ac_cv_target_alias=$ac_cv_host_alias
1657 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1658   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1659 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1660    { (exit 1); exit 1; }; }
1661
1662 fi
1663 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1664 echo "${ECHO_T}$ac_cv_target" >&6
1665 target=$ac_cv_target
1666 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1667 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1668 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1669
1670
1671 # The aliases save the names the user supplied, while $host etc.
1672 # will get canonicalized.
1673 test -n "$target_alias" &&
1674   test "$program_prefix$program_suffix$program_transform_name" = \
1675     NONENONEs,x,x, &&
1676   program_prefix=${target_alias}-
1677 test "$program_prefix" != NONE &&
1678   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1679 # Use a double $ so make ignores it.
1680 test "$program_suffix" != NONE &&
1681   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1682 # Double any \ or $.  echo might interpret backslashes.
1683 # By default was `s,x,x', remove it if useless.
1684 cat <<\_ACEOF >conftest.sed
1685 s/[\\$]/&&/g;s/;s,x,x,$//
1686 _ACEOF
1687 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1688 rm conftest.sed
1689
1690
1691
1692 # Get 'install' or 'install-sh' and its variants.
1693 # Find a good install program.  We prefer a C program (faster),
1694 # so one script is as good as another.  But avoid the broken or
1695 # incompatible versions:
1696 # SysV /etc/install, /usr/sbin/install
1697 # SunOS /usr/etc/install
1698 # IRIX /sbin/install
1699 # AIX /bin/install
1700 # AmigaOS /C/install, which installs bootblocks on floppy discs
1701 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1702 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1703 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1704 # OS/2's system install, which has a completely different semantic
1705 # ./install, which can be erroneously created by make from ./install.sh.
1706 # Reject install programs that cannot install multiple files.
1707 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1708 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1709 if test -z "$INSTALL"; then
1710 if test "${ac_cv_path_install+set}" = set; then
1711   echo $ECHO_N "(cached) $ECHO_C" >&6
1712 else
1713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1714 for as_dir in $PATH
1715 do
1716   IFS=$as_save_IFS
1717   test -z "$as_dir" && as_dir=.
1718   # Account for people who put trailing slashes in PATH elements.
1719 case $as_dir/ in
1720   ./ | .// | /cC/* | \
1721   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1722   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1723   /usr/ucb/* ) ;;
1724   *)
1725     # OSF1 and SCO ODT 3.0 have their own names for install.
1726     # Don't use installbsd from OSF since it installs stuff as root
1727     # by default.
1728     for ac_prog in ginstall scoinst install; do
1729       for ac_exec_ext in '' $ac_executable_extensions; do
1730         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1731           if test $ac_prog = install &&
1732             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1733             # AIX install.  It has an incompatible calling convention.
1734             :
1735           elif test $ac_prog = install &&
1736             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1737             # program-specific install script used by HP pwplus--don't use.
1738             :
1739           else
1740             rm -rf conftest.one conftest.two conftest.dir
1741             echo one > conftest.one
1742             echo two > conftest.two
1743             mkdir conftest.dir
1744             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1745               test -s conftest.one && test -s conftest.two &&
1746               test -s conftest.dir/conftest.one &&
1747               test -s conftest.dir/conftest.two
1748             then
1749               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1750               break 3
1751             fi
1752           fi
1753         fi
1754       done
1755     done
1756     ;;
1757 esac
1758 done
1759
1760 rm -rf conftest.one conftest.two conftest.dir
1761
1762 fi
1763   if test "${ac_cv_path_install+set}" = set; then
1764     INSTALL=$ac_cv_path_install
1765   else
1766     # As a last resort, use the slow shell script.  Don't cache a
1767     # value for INSTALL within a source directory, because that will
1768     # break other packages using the cache if that directory is
1769     # removed, or if the value is a relative name.
1770     INSTALL=$ac_install_sh
1771   fi
1772 fi
1773 echo "$as_me:$LINENO: result: $INSTALL" >&5
1774 echo "${ECHO_T}$INSTALL" >&6
1775
1776 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1777 # It thinks the first close brace ends the variable substitution.
1778 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1779
1780 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1781
1782 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1783
1784 echo "$as_me:$LINENO: checking whether ln works" >&5
1785 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1786 if test "${acx_cv_prog_LN+set}" = set; then
1787   echo $ECHO_N "(cached) $ECHO_C" >&6
1788 else
1789   rm -f conftestdata_t
1790 echo >conftestdata_f
1791 if ln conftestdata_f conftestdata_t 2>/dev/null
1792 then
1793   acx_cv_prog_LN=ln
1794 else
1795   acx_cv_prog_LN=no
1796 fi
1797 rm -f conftestdata_f conftestdata_t
1798
1799 fi
1800 if test $acx_cv_prog_LN = no; then
1801   LN="cp"
1802   echo "$as_me:$LINENO: result: no, using $LN" >&5
1803 echo "${ECHO_T}no, using $LN" >&6
1804 else
1805   LN="$acx_cv_prog_LN"
1806   echo "$as_me:$LINENO: result: yes" >&5
1807 echo "${ECHO_T}yes" >&6
1808 fi
1809
1810 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1811 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1812 LN_S=$as_ln_s
1813 if test "$LN_S" = "ln -s"; then
1814   echo "$as_me:$LINENO: result: yes" >&5
1815 echo "${ECHO_T}yes" >&6
1816 else
1817   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1818 echo "${ECHO_T}no, using $LN_S" >&6
1819 fi
1820
1821
1822 ### we might need to use some other shell than /bin/sh for running subshells
1823 ### If we are on Windows, search for the shell.  This will permit people
1824 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1825 ### without also having to set CONFIG_SHELL.  This code will work when
1826 ### using bash, which sets OSTYPE.
1827 case "${OSTYPE}" in
1828 *win32*)
1829   if test x${CONFIG_SHELL} = x ; then
1830     if test ! -f /bin/sh ; then
1831       if test x${SHELL} != x && test -f ${SHELL} ; then
1832         CONFIG_SHELL=${SHELL}
1833         export CONFIG_SHELL
1834       else
1835         for prog in sh sh.exe bash bash.exe; do
1836           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1837           for dir in $PATH; do
1838             test -z "$dir" && dir=.
1839             if test -f $dir/$prog; then
1840               CONFIG_SHELL=$dir/$prog
1841               export CONFIG_SHELL
1842               break
1843             fi
1844           done
1845           IFS="$save_ifs"
1846           test -n "${CONFIG_SHELL}" && break
1847         done
1848       fi
1849     fi
1850   fi
1851   ;;
1852 esac
1853
1854 config_shell=${CONFIG_SHELL-/bin/sh}
1855
1856 moveifchange=${srcdir}/move-if-change
1857
1858 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1859
1860 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1861 # a relative path.
1862 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1863   INSTALL="${srcpwd}/install-sh -c"
1864 fi
1865
1866 # Set srcdir to "." if that's what it is.
1867 # This is important for multilib support.
1868 pwd=`${PWDCMD-pwd}`
1869 if test "${pwd}" = "${srcpwd}" ; then
1870   srcdir=.
1871 fi
1872
1873 topsrcdir=$srcpwd
1874
1875 extra_host_args=
1876
1877 ### To add a new directory to the tree, first choose whether it is a target
1878 ### or a host dependent tool.  Then put it into the appropriate list
1879 ### (library or tools, host or target), doing a dependency sort.
1880
1881 # Subdirs will be configured in the order listed in build_configdirs,
1882 # configdirs, or target_configdirs; see the serialization section below.
1883
1884 # Dependency sorting is only needed when *configuration* must be done in
1885 # a particular order.  In all cases a dependency should be specified in
1886 # the Makefile, whether or not it's implicitly specified here.
1887
1888 # Double entries in build_configdirs, configdirs, or target_configdirs may
1889 # cause circular dependencies and break everything horribly.
1890
1891 # these library is used by various programs built for the build
1892 # environment
1893 #
1894 build_libs="build-libiberty"
1895
1896 # these tools are built for the build environment
1897 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1898
1899 # these libraries are used by various programs built for the host environment
1900 #
1901 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1902
1903 # these tools are built for the host environment
1904 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1905 # know that we are building the simulator.
1906 # binutils, gas and ld appear in that order because it makes sense to run
1907 # "make check" in that particular order.
1908 # If --enable-gold is used, "gold" will replace "ld".
1909 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"
1910
1911 # libgcj represents the runtime libraries only used by gcj.
1912 libgcj="target-libffi \
1913         target-zlib \
1914         target-qthreads \
1915         target-libjava"
1916
1917 # these libraries are built for the target environment, and are built after
1918 # the host libraries and the host tools (which may be a cross compiler)
1919 #
1920 target_libraries="target-libgcc \
1921                 target-libiberty \
1922                 target-libgloss \
1923                 target-newlib \
1924                 target-libgomp \
1925                 target-libstdc++-v3 \
1926                 target-libmudflap \
1927                 target-libssp \
1928                 target-libgfortran \
1929                 target-boehm-gc \
1930                 ${libgcj} \
1931                 target-libobjc \
1932                 target-libada"
1933
1934 # these tools are built using the target libraries, and are intended to
1935 # run only in the target environment
1936 #
1937 # note: any program that *uses* libraries that are in the "target_libraries"
1938 # list belongs in this list.  those programs are also very likely
1939 # candidates for the "native_only" list which follows
1940 #
1941 target_tools="target-examples target-groff target-gperf target-rda"
1942
1943 ################################################################################
1944
1945 ## All tools belong in one of the four categories, and are assigned above
1946 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1947 ## is important because configure will choke if they ever get through.
1948 ## ${configdirs} is directories we build using the host tools.
1949 ## ${target_configdirs} is directories we build using the target tools.
1950 configdirs=`echo ${host_libs} ${host_tools}`
1951 target_configdirs=`echo ${target_libraries} ${target_tools}`
1952 build_configdirs=`echo ${build_libs} ${build_tools}`
1953
1954
1955
1956 ################################################################################
1957
1958 srcname="gnu development package"
1959
1960 # This gets set non-empty for some net releases of packages.
1961 appdirs=""
1962
1963 # Define is_cross_compiler to save on calls to 'test'.
1964 is_cross_compiler=
1965 if test x"${host}" = x"${target}" ; then
1966   is_cross_compiler=no
1967 else
1968   is_cross_compiler=yes
1969 fi
1970
1971 # Find the build and target subdir names.
1972
1973 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1974 # have matching libraries, they should use host libraries: Makefile.tpl
1975 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1976 # However, they still use the build modules, because the corresponding
1977 # host modules (e.g. bison) are only built for the host when bootstrap
1978 # finishes. So:
1979 # - build_subdir is where we find build modules, and never changes.
1980 # - build_libsubdir is where we find build libraries, and can be overridden.
1981
1982 # Prefix 'build-' so this never conflicts with target_subdir.
1983 build_subdir="build-${build_noncanonical}"
1984
1985 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1986 if test "${with_build_libsubdir+set}" = set; then
1987   withval="$with_build_libsubdir"
1988   build_libsubdir="$withval"
1989 else
1990   build_libsubdir="$build_subdir"
1991 fi;
1992 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1993 if ( test $srcdir = . && test -d gcc ) \
1994    || test -d $srcdir/../host-${host_noncanonical}; then
1995   host_subdir="host-${host_noncanonical}"
1996 else
1997   host_subdir=.
1998 fi
1999 # No prefix.
2000 target_subdir=${target_noncanonical}
2001
2002
2003 # Skipdirs are removed silently.
2004 skipdirs=
2005 # Noconfigdirs are removed loudly.
2006 noconfigdirs=""
2007
2008 use_gnu_ld=
2009 # Make sure we don't let GNU ld be added if we didn't want it.
2010 if test x$with_gnu_ld = xno ; then
2011   use_gnu_ld=no
2012   noconfigdirs="$noconfigdirs ld gold"
2013 fi
2014
2015 use_gnu_as=
2016 # Make sure we don't let GNU as be added if we didn't want it.
2017 if test x$with_gnu_as = xno ; then
2018   use_gnu_as=no
2019   noconfigdirs="$noconfigdirs gas"
2020 fi
2021
2022 # some tools are so dependent upon X11 that if we're not building with X,
2023 # it's not even worth trying to configure, much less build, that tool.
2024
2025 case ${with_x} in
2026   yes | "") ;; # the default value for this tree is that X11 is available
2027   no)
2028     skipdirs="${skipdirs} tk itcl libgui"
2029     # We won't be able to build gdbtk without X.
2030     enable_gdbtk=no
2031     ;;
2032   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2033 esac
2034
2035 # Some tools are only suitable for building in a "native" situation.
2036 # Remove these if host!=target.
2037 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"
2038
2039 # Similarly, some are only suitable for cross toolchains.
2040 # Remove these if host=target.
2041 cross_only="target-libgloss target-newlib target-opcodes"
2042
2043 case $is_cross_compiler in
2044   no) skipdirs="${skipdirs} ${cross_only}" ;;
2045   yes) skipdirs="${skipdirs} ${native_only}" ;;
2046 esac
2047
2048 # If both --with-headers and --with-libs are specified, default to
2049 # --without-newlib.
2050 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2051    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2052   if test x"${with_newlib}" = x ; then
2053     with_newlib=no
2054   fi
2055 fi
2056
2057 # Recognize --with-newlib/--without-newlib.
2058 case ${with_newlib} in
2059   no) skipdirs="${skipdirs} target-newlib" ;;
2060   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2061 esac
2062
2063 # Handle --enable-gold.
2064
2065 # Check whether --enable-gold or --disable-gold was given.
2066 if test "${enable_gold+set}" = set; then
2067   enableval="$enable_gold"
2068   ENABLE_GOLD=$enableval
2069 else
2070   ENABLE_GOLD=no
2071 fi;
2072 if test "${ENABLE_GOLD}" = "yes"; then
2073   # Check for ELF target.
2074   is_elf=no
2075   case "${target}" in
2076     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2077     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2078     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2079       case "${target}" in
2080         *-*-linux*aout* | *-*-linux*oldld*)
2081           ;;
2082         *)
2083           is_elf=yes
2084           ;;
2085       esac
2086   esac
2087
2088   if test "$is_elf" = "yes"; then
2089     # Check for target supported by gold.
2090     case "${target}" in
2091       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2092         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2093         ;;
2094     esac
2095   fi
2096 fi
2097
2098 # Configure extra directories which are host specific
2099
2100 case "${host}" in
2101   *-cygwin*)
2102     configdirs="$configdirs libtermcap" ;;
2103 esac
2104
2105 # A target can indicate whether a language isn't supported for some reason.
2106 # Only spaces may be used in this macro; not newlines or tabs.
2107 unsupported_languages=
2108
2109 # Remove more programs from consideration, based on the host or
2110 # target this usually means that a port of the program doesn't
2111 # exist yet.
2112
2113 case "${host}" in
2114   hppa*64*-*-*)
2115     noconfigdirs="$noconfigdirs byacc"
2116     ;;
2117   i[3456789]86-*-vsta)
2118     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2119     ;;
2120   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2121     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2122     ;;
2123   x86_64-*-mingw*)
2124     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2125     ;;
2126   i[3456789]86-*-mingw32*)
2127     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2128     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2129     ;;
2130   i[3456789]86-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2132     ;;
2133   *-*-cygwin*)
2134     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2135     ;;
2136   *-*-netbsd*)
2137     noconfigdirs="$noconfigdirs rcs"
2138     ;;
2139   ppc*-*-pe)
2140     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2141     ;;
2142   powerpc-*-beos*)
2143     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2144     ;;
2145 esac
2146
2147
2148 # Check whether --enable-libada or --disable-libada was given.
2149 if test "${enable_libada+set}" = set; then
2150   enableval="$enable_libada"
2151   ENABLE_LIBADA=$enableval
2152 else
2153   ENABLE_LIBADA=yes
2154 fi;
2155 if test "${ENABLE_LIBADA}" != "yes" ; then
2156   noconfigdirs="$noconfigdirs gnattools"
2157 fi
2158
2159 # Check whether --enable-libssp or --disable-libssp was given.
2160 if test "${enable_libssp+set}" = set; then
2161   enableval="$enable_libssp"
2162   ENABLE_LIBSSP=$enableval
2163 else
2164   ENABLE_LIBSSP=yes
2165 fi;
2166
2167 # Save it here so that, even in case of --enable-libgcj, if the Java
2168 # front-end isn't enabled, we still get libgcj disabled.
2169 libgcj_saved=$libgcj
2170 case $enable_libgcj in
2171 yes)
2172   # If we reset it here, it won't get added to noconfigdirs in the
2173   # target-specific build rules, so it will be forcibly enabled
2174   # (unless the Java language itself isn't enabled).
2175   libgcj=
2176   ;;
2177 no)
2178   # Make sure we get it printed in the list of not supported target libs.
2179   noconfigdirs="$noconfigdirs ${libgcj}"
2180   ;;
2181 esac
2182
2183
2184 # Disable libmudflap on some systems.
2185 if test x$enable_libmudflap = x ; then
2186     case "${target}" in
2187     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2188         # Enable libmudflap by default in GNU and friends.
2189         ;;
2190     *-*-freebsd*)
2191         # Enable libmudflap by default in FreeBSD.
2192         ;;
2193     *)
2194         # Disable it by default everywhere else.
2195         noconfigdirs="$noconfigdirs target-libmudflap"
2196         ;;
2197     esac
2198 fi
2199
2200 # Disable libgomp on non POSIX hosted systems.
2201 if test x$enable_libgomp = x ; then
2202     # Enable libgomp by default on hosted POSIX systems.
2203     case "${target}" in
2204     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2205         ;;
2206     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2207         ;;
2208     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2209         ;;
2210     *-*-darwin* | *-*-aix*)
2211         ;;
2212     *)
2213         noconfigdirs="$noconfigdirs target-libgomp"
2214         ;;
2215     esac
2216 fi
2217
2218 # Default libgloss CPU subdirectory.
2219 libgloss_dir="$target_cpu"
2220
2221 case "${target}" in
2222   *-*-chorusos)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   powerpc-*-darwin*)
2226     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2227     noconfigdirs="$noconfigdirs sim target-rda"
2228     ;;
2229   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2230     noconfigdirs="$noconfigdirs ld gas gprof"
2231     noconfigdirs="$noconfigdirs sim target-rda"
2232     ;;
2233   *-*-darwin*)
2234     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2235     noconfigdirs="$noconfigdirs sim target-rda"
2236     noconfigdirs="$noconfigdirs ${libgcj}"
2237     ;;
2238   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2239     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2240     ;;
2241   *-*-freebsd*)
2242     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2243     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2244         && test -f /usr/local/include/gmp.h; then
2245       with_gmp=/usr/local
2246     fi
2247
2248     # Skip some stuff that's unsupported on some FreeBSD configurations.
2249     case "${target}" in
2250       i*86-*-*) ;;
2251       alpha*-*-*) ;;
2252       *)
2253         noconfigdirs="$noconfigdirs ${libgcj}"
2254         ;;
2255     esac
2256     ;;
2257   *-*-kaos*)
2258     # Remove unsupported stuff on all kaOS configurations.
2259     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2260     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2261     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2262     noconfigdirs="$noconfigdirs target-libgloss"
2263     ;;
2264   *-*-netbsd*)
2265     # Skip some stuff on all NetBSD configurations.
2266     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2267
2268     # Skip some stuff that's unsupported on some NetBSD configurations.
2269     case "${target}" in
2270       i*86-*-netbsdelf*) ;;
2271       arm*-*-netbsdelf*) ;;
2272       *)
2273         noconfigdirs="$noconfigdirs ${libgcj}"
2274         ;;
2275     esac
2276     ;;
2277   *-*-netware*)
2278     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2279     ;;
2280   *-*-rtems*)
2281     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2282     ;;
2283     # The tpf target doesn't support gdb yet.
2284   *-*-tpf*)
2285     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2286     ;;
2287   *-*-uclinux*)
2288     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2289     ;;
2290   *-*-vxworks*)
2291     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2292     ;;
2293   alpha*-dec-osf*)
2294     # ld works, but does not support shared libraries.
2295     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2296     # gas doesn't generate exception information.
2297     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2298     ;;
2299   alpha*-*-*vms*)
2300     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2301     ;;
2302   alpha*-*-linux*)
2303     # newlib is not 64 bit ready
2304     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2305     ;;
2306   alpha*-*-*)
2307     # newlib is not 64 bit ready
2308     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2309     ;;
2310   am33_2.0-*-linux*)
2311     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2312     ;;
2313   sh-*-linux*)
2314     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2315     ;;
2316   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2317     noconfigdirs="$noconfigdirs ${libgcj}"
2318     noconfigdirs="$noconfigdirs target-examples"
2319     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2320     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2321     noconfigdirs="$noconfigdirs expect dejagnu"
2322     # the C++ libraries don't build on top of CE's C libraries
2323     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2324     noconfigdirs="$noconfigdirs target-newlib"
2325     case "${host}" in
2326       *-*-cygwin*) ;; # keep gdb and readline
2327       *) noconfigdirs="$noconfigdirs gdb readline"
2328          ;;
2329     esac
2330     libgloss_dir=wince
2331     ;;
2332   arc-*-*)
2333     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2334     ;;
2335   arm-semi-aof )
2336     ;;
2337   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2338     noconfigdirs="$noconfigdirs ${libgcj}"
2339     libgloss_dir=arm
2340     ;;
2341   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2342     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2343     libgloss_dir=arm
2344     ;;
2345   arm*-*-linux-gnueabi)
2346     noconfigdirs="$noconfigdirs target-qthreads"
2347     case ${with_newlib} in
2348       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2349     esac
2350     libgloss_dir=arm
2351     ;;
2352   arm*-*-symbianelf*)
2353     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2354     libgloss_dir=arm
2355     ;;
2356   arm-*-pe*)
2357     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2358     ;;
2359   thumb-*-coff)
2360     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2361     ;;
2362   thumb-*-elf)
2363     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2364     ;;
2365   thumb-*-pe)
2366     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2367     ;;
2368   arm-*-riscix*)
2369     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2370     ;;
2371   avr-*-*)
2372     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2373     ;;
2374   bfin-*-*)
2375     noconfigdirs="$noconfigdirs gdb"
2376     if test x${is_cross_compiler} != xno ; then
2377       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2378     fi
2379     ;;
2380   c4x-*-* | tic4x-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   c54x*-*-* | tic54x-*-*)
2384     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2385     ;;
2386   cr16-*-*)
2387     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2388     ;;
2389   cris-*-* | crisv32-*-*)
2390     unsupported_languages="$unsupported_languages java"
2391     case "${target}" in
2392       *-*-aout)
2393         unsupported_languages="$unsupported_languages fortran"
2394         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2395       *-*-elf)
2396         noconfigdirs="$noconfigdirs target-boehm-gc";;
2397       *-*-linux*)
2398         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2399       *)
2400         unsupported_languages="$unsupported_languages fortran"
2401         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2402     esac
2403     libgloss_dir=cris
2404     ;;
2405   crx-*-*)
2406     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2407     ;;
2408   d10v-*-*)
2409     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2410     ;;
2411   d30v-*-*)
2412     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2413     ;;
2414   ep9312-*-elf | ep9312-*-coff)
2415     libgloss_dir=arm
2416     ;;
2417   fr30-*-elf*)
2418     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2419     ;;
2420   frv-*-*)
2421     noconfigdirs="$noconfigdirs ${libgcj}"
2422     ;;
2423   moxie-*-*)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     noconfigdirs="$noconfigdirs gprof"
2426     ;;
2427   h8300*-*-*)
2428     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2429     ;;
2430   h8500-*-*)
2431     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2432     ;;
2433   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2434     ;;
2435   hppa*64*-*-linux* | parisc*64*-*-linux*)
2436     # In this case, it's because the hppa64-linux target is for
2437     # the kernel only at this point and has no libc, and thus no
2438     # headers, crt*.o, etc., all of which are needed by these.
2439     noconfigdirs="$noconfigdirs target-zlib"
2440     ;;
2441   parisc*-*-linux* | hppa*-*-linux*)
2442     ;;
2443   hppa*-*-*elf* | \
2444   hppa*-*-lites* | \
2445   hppa*-*-openbsd* | \
2446   hppa*64*-*-*)
2447     noconfigdirs="$noconfigdirs ${libgcj}"
2448     ;;
2449   hppa*-hp-hpux11*)
2450     noconfigdirs="$noconfigdirs ld shellutils"
2451     ;;
2452   hppa*-*-pro*)
2453     libgloss_dir=pa
2454     ;;
2455   hppa*-*-*)
2456     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2457     # build on HP-UX 10.20.
2458     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2459     ;;
2460   i960-*-*)
2461     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2462     ;;
2463   ia64*-*-elf*)
2464     # No gdb support yet.
2465     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2466     ;;
2467   ia64*-**-hpux*)
2468     # No gdb or ld support yet.
2469     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2470     ;;
2471   ia64*-*-*vms*)
2472     # No gdb or ld support yet.
2473     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2474     ;;
2475   i370-*-opened*)
2476     ;;
2477   i[3456789]86-*-coff | i[3456789]86-*-elf)
2478     noconfigdirs="$noconfigdirs ${libgcj}"
2479     libgloss_dir=i386
2480     ;;
2481   i[3456789]86-*-linux*)
2482     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2483     # not build java stuff by default.
2484     case "${target}" in
2485       *-*-*libc1*)
2486         noconfigdirs="$noconfigdirs ${libgcj}";;
2487     esac
2488
2489     # This section makes it possible to build newlib natively on linux.
2490     # If we are using a cross compiler then don't configure newlib.
2491     if test x${is_cross_compiler} != xno ; then
2492       noconfigdirs="$noconfigdirs target-newlib"
2493     fi
2494     noconfigdirs="$noconfigdirs target-libgloss"
2495     # If we are not using a cross compiler, do configure newlib.
2496     # Note however, that newlib will only be configured in this situation
2497     # if the --with-newlib option has been given, because otherwise
2498     # 'target-newlib' will appear in skipdirs.
2499     ;;
2500   i[3456789]86-*-mingw32*)
2501     target_configdirs="$target_configdirs target-winsup"
2502     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2503     ;;
2504   x86_64-*-mingw*)
2505     target_configdirs="$target_configdirs target-winsup"
2506     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2507     ;;
2508   *-*-cygwin*)
2509     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2510     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2511     # always build newlib if winsup directory is present.
2512     if test -d "$srcdir/winsup/cygwin"; then
2513       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2514     elif test -d "$srcdir/newlib"; then
2515       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2516     fi
2517     ;;
2518   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2519   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2520     ;;
2521   i[3456789]86-*-pe)
2522     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2523     ;;
2524   i[3456789]86-*-sco3.2v5*)
2525     # The linker does not yet know about weak symbols in COFF,
2526     # and is not configured to handle mixed ELF and COFF.
2527     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2528     ;;
2529   i[3456789]86-*-sco*)
2530     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2531     ;;
2532   i[3456789]86-*-solaris2*)
2533     noconfigdirs="$noconfigdirs target-libgloss"
2534     ;;
2535   i[3456789]86-*-sysv4*)
2536     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2537     ;;
2538   i[3456789]86-*-beos*)
2539     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2540     ;;
2541   i[3456789]86-*-rdos*)
2542     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2543     ;;
2544   m32r-*-*)
2545     noconfigdirs="$noconfigdirs ${libgcj}"
2546     ;;
2547   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2548     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2549     libgloss_dir=m68hc11
2550     ;;
2551   m68k-*-elf*)
2552     noconfigdirs="$noconfigdirs ${libgcj}"
2553     ;;
2554   m68k-*-coff*)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     ;;
2557   m68*-*-* | fido-*-*)
2558     libgloss_dir=m68k
2559     ;;
2560   mcore-*-pe*)
2561   # The EPOC C++ environment does not support exceptions or rtti,
2562   # and so building libstdc++-v3 tends not to always work.
2563     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2564     ;;
2565   mmix-*-*)
2566     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2567     unsupported_languages="$unsupported_languages fortran java"
2568     ;;
2569   mn10200-*-*)
2570     noconfigdirs="$noconfigdirs ${libgcj}"
2571     ;;
2572   mn10300-*-*)
2573     noconfigdirs="$noconfigdirs ${libgcj}"
2574     ;;
2575   mt-*-*)
2576     noconfigdirs="$noconfigdirs sim"
2577     ;;
2578   powerpc-*-aix*)
2579     # copied from rs6000-*-* entry
2580     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2581     ;;
2582   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2583     target_configdirs="$target_configdirs target-winsup"
2584     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2585     # always build newlib.
2586     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2587     ;;
2588     # This is temporary until we can link against shared libraries
2589   powerpcle-*-solaris*)
2590     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2591     libgloss_dir=rs6000
2592     ;;
2593   powerpc-*-beos*)
2594     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2595     ;;
2596   powerpc-*-eabi)
2597     noconfigdirs="$noconfigdirs ${libgcj}"
2598     libgloss_dir=rs6000
2599     ;;
2600   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2601     libgloss_dir=rs6000
2602     ;;
2603   rs6000-*-lynxos*)
2604     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2605     ;;
2606   rs6000-*-aix*)
2607     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2608     ;;
2609   rs6000-*-*)
2610     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2611     ;;
2612   m68k-apollo-*)
2613     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2614     ;;
2615   mips*-sde-elf*)
2616     skipdirs="$skipdirs target-libiberty"
2617     noconfigdirs="$noconfigdirs ${libgcj}"
2618     if test x$with_newlib = xyes; then
2619       noconfigdirs="$noconfigdirs gprof"
2620     fi
2621     libgloss_dir=mips
2622     ;;
2623   mips*-*-irix5*)
2624     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2625     ;;
2626   mips*-*-irix6*)
2627     # Linking libjava exceeds command-line length limits on at least
2628     # IRIX 6.2, but not on IRIX 6.5.
2629     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2630     # <oldham@codesourcery.com>
2631     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2632     ;;
2633   mips*-*-bsd*)
2634     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2635     ;;
2636   mips*-*-linux*)
2637     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2638     ;;
2639   mips*-*-*)
2640     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2641     libgloss_dir=mips
2642     ;;
2643   romp-*-*)
2644     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2645     ;;
2646   sh-*-* | sh64-*-*)
2647     case "${host}" in
2648       i[3456789]86-*-vsta) ;; # don't add gprof back in
2649       i[3456789]86-*-go32*) ;; # don't add gprof back in
2650       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2651       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2652     esac
2653     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2654     ;;
2655   sparclet-*-aout* | sparc86x-*-*)
2656     libgloss_dir=sparc
2657     ;;
2658   sparc-*-elf*)
2659     noconfigdirs="$noconfigdirs ${libgcj}"
2660     ;;
2661   sparc64-*-elf*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     libgloss_dir=sparc
2664     ;;
2665   sparclite-*-*)
2666     noconfigdirs="$noconfigdirs ${libgcj}"
2667     libgloss_dir=sparc
2668     ;;
2669   sparc-*-sunos4*)
2670     noconfigdirs="$noconfigdirs ${libgcj}"
2671     if test x${is_cross_compiler} != xno ; then
2672            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2673     else
2674            use_gnu_ld=no
2675     fi
2676     ;;
2677   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2678     noconfigdirs="$noconfigdirs ${libgcj}"
2679     ;;
2680   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2681     ;;
2682   v810-*-*)
2683     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2684     ;;
2685   v850-*-*)
2686     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2687     ;;
2688   v850e-*-*)
2689     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2690     ;;
2691   v850ea-*-*)
2692     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2693     ;;
2694   vax-*-vms)
2695     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2696     ;;
2697   vax-*-*)
2698     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2699     ;;
2700   xtensa*-*-*)
2701     noconfigdirs="$noconfigdirs ${libgcj}"
2702     ;;
2703   ip2k-*-*)
2704     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2705     ;;
2706   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2707     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2708     ;;
2709   *-*-lynxos*)
2710     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2711     ;;
2712   *-*-*)
2713     noconfigdirs="$noconfigdirs ${libgcj}"
2714     ;;
2715 esac
2716
2717 # If we aren't building newlib, then don't build libgloss, since libgloss
2718 # depends upon some newlib header files.
2719 case "${noconfigdirs}" in
2720   *target-libgloss*) ;;
2721   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2722 esac
2723
2724 # Work in distributions that contain no compiler tools, like Autoconf.
2725 tentative_cc=""
2726 host_makefile_frag=/dev/null
2727 if test -d ${srcdir}/config ; then
2728 case "${host}" in
2729   m68k-hp-hpux*)
2730     # Avoid "too much defining" errors from HPUX compiler.
2731     tentative_cc="cc -Wp,-H256000"
2732     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2733     # If it's HP/UX ar, this should be harmless.
2734     RANLIB="ar ts"
2735     ;;
2736   m68k-apollo-sysv*)
2737     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2738     ;;
2739   m68k-apollo-bsd*)
2740     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2741     # chokes on bfd, the compiler won't let you assign integers to enums, and
2742     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2743     # the apollo compiler" (the preferred version of GCC could be called cc,
2744     # or whatever), but I'm not sure leaving CC as cc is any better...
2745     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2746     # Used to have BISON=yacc.
2747     tentative_cc=gcc
2748     ;;
2749   m88k-dg-dgux*)
2750     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2751     ;;
2752   m88k-harris-cxux*)
2753     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2754     tentative_cc="cc -Xa"
2755     host_makefile_frag="config/mh-cxux"
2756     ;;
2757   m88k-motorola-sysv*)
2758     ;;
2759   mips*-dec-ultrix*)
2760     tentative_cc="cc -Wf,-XNg1000"
2761     host_makefile_frag="config/mh-decstation"
2762     ;;
2763   mips*-nec-sysv4*)
2764     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2765     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2766     host_makefile_frag="config/mh-necv4"
2767     ;;
2768   mips*-sgi-irix4*)
2769     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2770     # environment.  Also bump switch table size so that cp-parse will
2771     # compile.  Bump string length limit so linker builds.
2772     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2773     ;;
2774   mips*-*-sysv4*)
2775     host_makefile_frag="config/mh-sysv4"
2776     ;;
2777   mips*-*-sysv*)
2778     # This is for a MIPS running RISC/os 4.52C.
2779
2780     # This is needed for GDB, but needs to be in the top-level make because
2781     # if a library is compiled with the bsd headers and gets linked with the
2782     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2783     # a different size).
2784     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2785     # known except to select the sysv environment.  Could we use /proc instead?
2786     # These "sysv environments" and "bsd environments" often end up being a pain.
2787     #
2788     # This is not part of CFLAGS because perhaps not all C compilers have this
2789     # option.
2790     tentative_cc="cc -systype sysv"
2791     ;;
2792   i370-ibm-opened*)
2793     tentative_cc="c89"
2794     ;;
2795   i[3456789]86-*-sysv5*)
2796     host_makefile_frag="config/mh-sysv5"
2797     ;;
2798   i[3456789]86-*-dgux*)
2799     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2800     host_makefile_frag="config/mh-dgux386"
2801     ;;
2802   i[3456789]86-ncr-sysv4.3*)
2803     # The MetaWare compiler will generate a copyright message unless you
2804     # turn it off by adding the -Hnocopyr flag.
2805     tentative_cc="cc -Hnocopyr"
2806     ;;
2807   i[3456789]86-ncr-sysv4*)
2808     # for an NCR 3000 (i486/SVR4) system.
2809     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2810     # This compiler not only emits obnoxious copyright messages every time
2811     # you run it, but it chokes and dies on a whole bunch of GNU source
2812     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2813     tentative_cc="/usr/ccs/ATT/cc"
2814     host_makefile_frag="config/mh-ncr3000"
2815     ;;
2816   i[3456789]86-*-sco3.2v5*)
2817     ;;
2818   i[3456789]86-*-sco*)
2819     # The native C compiler botches some simple uses of const.  Unfortunately,
2820     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2821     tentative_cc="cc -Dconst="
2822     host_makefile_frag="config/mh-sco"
2823     ;;
2824   i[3456789]86-*-udk*)
2825     host_makefile_frag="config/mh-sysv5"
2826     ;;
2827   i[3456789]86-*-solaris2*)
2828     host_makefile_frag="config/mh-sysv4"
2829     ;;
2830   i[3456789]86-*-msdosdjgpp*)
2831     host_makefile_frag="config/mh-djgpp"
2832     ;;
2833   *-cygwin*)
2834
2835 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2836 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2837 echo a >cygwin-cat-check
2838 if test `cat cygwin-cat-check` == a ; then
2839   rm cygwin-cat-check
2840   echo "$as_me:$LINENO: result: yes" >&5
2841 echo "${ECHO_T}yes" >&6
2842 else
2843   rm cygwin-cat-check
2844   echo "$as_me:$LINENO: result: no" >&5
2845 echo "${ECHO_T}no" >&6
2846   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2847   Please either mount the build directory in binary mode or run the following
2848   commands before running any configure script:
2849 set -o igncr
2850 export SHELLOPTS
2851   " >&5
2852 echo "$as_me: error: The cat command does not ignore carriage return characters.
2853   Please either mount the build directory in binary mode or run the following
2854   commands before running any configure script:
2855 set -o igncr
2856 export SHELLOPTS
2857   " >&2;}
2858    { (exit 1); exit 1; }; }
2859 fi
2860
2861     host_makefile_frag="config/mh-cygwin"
2862     ;;
2863   *-mingw*)
2864     host_makefile_frag="config/mh-mingw"
2865     ;;
2866   *-interix*)
2867     host_makefile_frag="config/mh-interix"
2868     ;;
2869   vax-*-ultrix2*)
2870     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2871     tentative_cc=gcc
2872     ;;
2873   *-*-solaris2*)
2874     host_makefile_frag="config/mh-solaris"
2875     ;;
2876   m68k-sun-sunos*)
2877     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2878     # without overflowing the jump tables (-J says to use a 32 bit table)
2879     tentative_cc="cc -J"
2880     ;;
2881   hppa*-hp-hpux10*)
2882     tentative_cc="cc -Wp,-H256000"
2883     host_makefile_frag="config/mh-pa-hpux10"
2884     ;;
2885   hppa*-hp-hpux* | hppa*-*-hiux*)
2886     tentative_cc="cc -Wp,-H256000"
2887     host_makefile_frag="config/mh-pa"
2888     ;;
2889   hppa*-*)
2890     host_makefile_frag="config/mh-pa"
2891     ;;
2892   *-hp-hpux* | *-*-hiux*)
2893     tentative_cc="cc -Wp,-H256000"
2894     ;;
2895   rs6000-*-lynxos*)
2896     # /bin/cc is less than useful for our purposes.  Always use GCC
2897     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2898     host_makefile_frag="config/mh-lynxrs6k"
2899     ;;
2900   powerpc-*-darwin*)
2901     host_makefile_frag="config/mh-ppc-darwin"
2902     ;;
2903   powerpc-*-aix*)
2904     host_makefile_frag="config/mh-ppc-aix"
2905     ;;
2906   rs6000-*-aix*)
2907     host_makefile_frag="config/mh-ppc-aix"
2908     ;;
2909   *-*-lynxos*)
2910     # /bin/cc is less than useful for our purposes.  Always use GCC
2911     tentative_cc="/bin/gcc"
2912     ;;
2913   *-*-sysv4*)
2914     host_makefile_frag="config/mh-sysv4"
2915     ;;
2916   # This is placed last to prevent interfering with the cases above.
2917   i[3456789]86-*-*)
2918     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2919     host_makefile_frag="config/mh-x86omitfp"
2920     ;;
2921 esac
2922 fi
2923
2924 # If we aren't going to be using gcc, see if we can extract a definition
2925 # of CC from the fragment.
2926 # Actually, use the 'pre-extracted' version above.
2927 if test -z "${CC}" && test "${build}" = "${host}" ; then
2928   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2929   found=
2930   for dir in $PATH; do
2931     test -z "$dir" && dir=.
2932     if test -f $dir/gcc; then
2933       found=yes
2934       break
2935     fi
2936   done
2937   IFS="$save_ifs"
2938   if test -z "${found}" && test -n "${tentative_cc}" ; then
2939     CC=$tentative_cc
2940   fi
2941 fi
2942
2943 if test "${build}" != "${host}" ; then
2944   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2945   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2946   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2947   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2948   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2949   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2950   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2951   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2952   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2953   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2954   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2955   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2956 else
2957   AR_FOR_BUILD="\$(AR)"
2958   AS_FOR_BUILD="\$(AS)"
2959   CC_FOR_BUILD="\$(CC)"
2960   CXX_FOR_BUILD="\$(CXX)"
2961   GCJ_FOR_BUILD="\$(GCJ)"
2962   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2963   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2964   LD_FOR_BUILD="\$(LD)"
2965   NM_FOR_BUILD="\$(NM)"
2966   RANLIB_FOR_BUILD="\$(RANLIB)"
2967   WINDRES_FOR_BUILD="\$(WINDRES)"
2968   WINDMC_FOR_BUILD="\$(WINDMC)"
2969 fi
2970
2971 ac_ext=c
2972 ac_cpp='$CPP $CPPFLAGS'
2973 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2974 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2975 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2976 if test -n "$ac_tool_prefix"; then
2977   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2978 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2979 echo "$as_me:$LINENO: checking for $ac_word" >&5
2980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2981 if test "${ac_cv_prog_CC+set}" = set; then
2982   echo $ECHO_N "(cached) $ECHO_C" >&6
2983 else
2984   if test -n "$CC"; then
2985   ac_cv_prog_CC="$CC" # Let the user override the test.
2986 else
2987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2988 for as_dir in $PATH
2989 do
2990   IFS=$as_save_IFS
2991   test -z "$as_dir" && as_dir=.
2992   for ac_exec_ext in '' $ac_executable_extensions; do
2993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2994     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2996     break 2
2997   fi
2998 done
2999 done
3000
3001 fi
3002 fi
3003 CC=$ac_cv_prog_CC
3004 if test -n "$CC"; then
3005   echo "$as_me:$LINENO: result: $CC" >&5
3006 echo "${ECHO_T}$CC" >&6
3007 else
3008   echo "$as_me:$LINENO: result: no" >&5
3009 echo "${ECHO_T}no" >&6
3010 fi
3011
3012 fi
3013 if test -z "$ac_cv_prog_CC"; then
3014   ac_ct_CC=$CC
3015   # Extract the first word of "gcc", so it can be a program name with args.
3016 set dummy gcc; ac_word=$2
3017 echo "$as_me:$LINENO: checking for $ac_word" >&5
3018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3019 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3020   echo $ECHO_N "(cached) $ECHO_C" >&6
3021 else
3022   if test -n "$ac_ct_CC"; then
3023   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3024 else
3025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3026 for as_dir in $PATH
3027 do
3028   IFS=$as_save_IFS
3029   test -z "$as_dir" && as_dir=.
3030   for ac_exec_ext in '' $ac_executable_extensions; do
3031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3032     ac_cv_prog_ac_ct_CC="gcc"
3033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3034     break 2
3035   fi
3036 done
3037 done
3038
3039 fi
3040 fi
3041 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3042 if test -n "$ac_ct_CC"; then
3043   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3044 echo "${ECHO_T}$ac_ct_CC" >&6
3045 else
3046   echo "$as_me:$LINENO: result: no" >&5
3047 echo "${ECHO_T}no" >&6
3048 fi
3049
3050   CC=$ac_ct_CC
3051 else
3052   CC="$ac_cv_prog_CC"
3053 fi
3054
3055 if test -z "$CC"; then
3056   if test -n "$ac_tool_prefix"; then
3057   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3058 set dummy ${ac_tool_prefix}cc; ac_word=$2
3059 echo "$as_me:$LINENO: checking for $ac_word" >&5
3060 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3061 if test "${ac_cv_prog_CC+set}" = set; then
3062   echo $ECHO_N "(cached) $ECHO_C" >&6
3063 else
3064   if test -n "$CC"; then
3065   ac_cv_prog_CC="$CC" # Let the user override the test.
3066 else
3067 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3068 for as_dir in $PATH
3069 do
3070   IFS=$as_save_IFS
3071   test -z "$as_dir" && as_dir=.
3072   for ac_exec_ext in '' $ac_executable_extensions; do
3073   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3074     ac_cv_prog_CC="${ac_tool_prefix}cc"
3075     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3076     break 2
3077   fi
3078 done
3079 done
3080
3081 fi
3082 fi
3083 CC=$ac_cv_prog_CC
3084 if test -n "$CC"; then
3085   echo "$as_me:$LINENO: result: $CC" >&5
3086 echo "${ECHO_T}$CC" >&6
3087 else
3088   echo "$as_me:$LINENO: result: no" >&5
3089 echo "${ECHO_T}no" >&6
3090 fi
3091
3092 fi
3093 if test -z "$ac_cv_prog_CC"; then
3094   ac_ct_CC=$CC
3095   # Extract the first word of "cc", so it can be a program name with args.
3096 set dummy cc; ac_word=$2
3097 echo "$as_me:$LINENO: checking for $ac_word" >&5
3098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3099 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3100   echo $ECHO_N "(cached) $ECHO_C" >&6
3101 else
3102   if test -n "$ac_ct_CC"; then
3103   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3104 else
3105 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3106 for as_dir in $PATH
3107 do
3108   IFS=$as_save_IFS
3109   test -z "$as_dir" && as_dir=.
3110   for ac_exec_ext in '' $ac_executable_extensions; do
3111   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3112     ac_cv_prog_ac_ct_CC="cc"
3113     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3114     break 2
3115   fi
3116 done
3117 done
3118
3119 fi
3120 fi
3121 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3122 if test -n "$ac_ct_CC"; then
3123   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3124 echo "${ECHO_T}$ac_ct_CC" >&6
3125 else
3126   echo "$as_me:$LINENO: result: no" >&5
3127 echo "${ECHO_T}no" >&6
3128 fi
3129
3130   CC=$ac_ct_CC
3131 else
3132   CC="$ac_cv_prog_CC"
3133 fi
3134
3135 fi
3136 if test -z "$CC"; then
3137   # Extract the first word of "cc", so it can be a program name with args.
3138 set dummy cc; ac_word=$2
3139 echo "$as_me:$LINENO: checking for $ac_word" >&5
3140 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3141 if test "${ac_cv_prog_CC+set}" = set; then
3142   echo $ECHO_N "(cached) $ECHO_C" >&6
3143 else
3144   if test -n "$CC"; then
3145   ac_cv_prog_CC="$CC" # Let the user override the test.
3146 else
3147   ac_prog_rejected=no
3148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3149 for as_dir in $PATH
3150 do
3151   IFS=$as_save_IFS
3152   test -z "$as_dir" && as_dir=.
3153   for ac_exec_ext in '' $ac_executable_extensions; do
3154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3155     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3156        ac_prog_rejected=yes
3157        continue
3158      fi
3159     ac_cv_prog_CC="cc"
3160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3161     break 2
3162   fi
3163 done
3164 done
3165
3166 if test $ac_prog_rejected = yes; then
3167   # We found a bogon in the path, so make sure we never use it.
3168   set dummy $ac_cv_prog_CC
3169   shift
3170   if test $# != 0; then
3171     # We chose a different compiler from the bogus one.
3172     # However, it has the same basename, so the bogon will be chosen
3173     # first if we set CC to just the basename; use the full file name.
3174     shift
3175     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3176   fi
3177 fi
3178 fi
3179 fi
3180 CC=$ac_cv_prog_CC
3181 if test -n "$CC"; then
3182   echo "$as_me:$LINENO: result: $CC" >&5
3183 echo "${ECHO_T}$CC" >&6
3184 else
3185   echo "$as_me:$LINENO: result: no" >&5
3186 echo "${ECHO_T}no" >&6
3187 fi
3188
3189 fi
3190 if test -z "$CC"; then
3191   if test -n "$ac_tool_prefix"; then
3192   for ac_prog in cl
3193   do
3194     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3195 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3196 echo "$as_me:$LINENO: checking for $ac_word" >&5
3197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3198 if test "${ac_cv_prog_CC+set}" = set; then
3199   echo $ECHO_N "(cached) $ECHO_C" >&6
3200 else
3201   if test -n "$CC"; then
3202   ac_cv_prog_CC="$CC" # Let the user override the test.
3203 else
3204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3205 for as_dir in $PATH
3206 do
3207   IFS=$as_save_IFS
3208   test -z "$as_dir" && as_dir=.
3209   for ac_exec_ext in '' $ac_executable_extensions; do
3210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3211     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3213     break 2
3214   fi
3215 done
3216 done
3217
3218 fi
3219 fi
3220 CC=$ac_cv_prog_CC
3221 if test -n "$CC"; then
3222   echo "$as_me:$LINENO: result: $CC" >&5
3223 echo "${ECHO_T}$CC" >&6
3224 else
3225   echo "$as_me:$LINENO: result: no" >&5
3226 echo "${ECHO_T}no" >&6
3227 fi
3228
3229     test -n "$CC" && break
3230   done
3231 fi
3232 if test -z "$CC"; then
3233   ac_ct_CC=$CC
3234   for ac_prog in cl
3235 do
3236   # Extract the first word of "$ac_prog", so it can be a program name with args.
3237 set dummy $ac_prog; ac_word=$2
3238 echo "$as_me:$LINENO: checking for $ac_word" >&5
3239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3240 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3241   echo $ECHO_N "(cached) $ECHO_C" >&6
3242 else
3243   if test -n "$ac_ct_CC"; then
3244   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3245 else
3246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3247 for as_dir in $PATH
3248 do
3249   IFS=$as_save_IFS
3250   test -z "$as_dir" && as_dir=.
3251   for ac_exec_ext in '' $ac_executable_extensions; do
3252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3253     ac_cv_prog_ac_ct_CC="$ac_prog"
3254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3255     break 2
3256   fi
3257 done
3258 done
3259
3260 fi
3261 fi
3262 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3263 if test -n "$ac_ct_CC"; then
3264   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3265 echo "${ECHO_T}$ac_ct_CC" >&6
3266 else
3267   echo "$as_me:$LINENO: result: no" >&5
3268 echo "${ECHO_T}no" >&6
3269 fi
3270
3271   test -n "$ac_ct_CC" && break
3272 done
3273
3274   CC=$ac_ct_CC
3275 fi
3276
3277 fi
3278
3279
3280 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3281 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3282 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3283 See \`config.log' for more details." >&5
3284 echo "$as_me: error: no acceptable C compiler found in \$PATH
3285 See \`config.log' for more details." >&2;}
3286    { (exit 1); exit 1; }; }; }
3287
3288 # Provide some information about the compiler.
3289 echo "$as_me:$LINENO:" \
3290      "checking for C compiler version" >&5
3291 ac_compiler=`set X $ac_compile; echo $2`
3292 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3293   (eval $ac_compiler --version </dev/null >&5) 2>&5
3294   ac_status=$?
3295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3296   (exit $ac_status); }
3297 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3298   (eval $ac_compiler -v </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
3308 cat >conftest.$ac_ext <<_ACEOF
3309 /* confdefs.h.  */
3310 _ACEOF
3311 cat confdefs.h >>conftest.$ac_ext
3312 cat >>conftest.$ac_ext <<_ACEOF
3313 /* end confdefs.h.  */
3314
3315 int
3316 main ()
3317 {
3318
3319   ;
3320   return 0;
3321 }
3322 _ACEOF
3323 ac_clean_files_save=$ac_clean_files
3324 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3325 # Try to create an executable without -o first, disregard a.out.
3326 # It will help us diagnose broken compilers, and finding out an intuition
3327 # of exeext.
3328 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3329 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3330 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3331 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3332   (eval $ac_link_default) 2>&5
3333   ac_status=$?
3334   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3335   (exit $ac_status); }; then
3336   # Find the output, starting from the most likely.  This scheme is
3337 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3338 # resort.
3339
3340 # Be careful to initialize this variable, since it used to be cached.
3341 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3342 ac_cv_exeext=
3343 # b.out is created by i960 compilers.
3344 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3345 do
3346   test -f "$ac_file" || continue
3347   case $ac_file in
3348     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3349         ;;
3350     conftest.$ac_ext )
3351         # This is the source file.
3352         ;;
3353     [ab].out )
3354         # We found the default executable, but exeext='' is most
3355         # certainly right.
3356         break;;
3357     *.* )
3358         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3359         # FIXME: I believe we export ac_cv_exeext for Libtool,
3360         # but it would be cool to find out if it's true.  Does anybody
3361         # maintain Libtool? --akim.
3362         export ac_cv_exeext
3363         break;;
3364     * )
3365         break;;
3366   esac
3367 done
3368 else
3369   echo "$as_me: failed program was:" >&5
3370 sed 's/^/| /' conftest.$ac_ext >&5
3371
3372 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3373 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3374 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3375 See \`config.log' for more details." >&5
3376 echo "$as_me: error: C compiler cannot create executables
3377 See \`config.log' for more details." >&2;}
3378    { (exit 77); exit 77; }; }; }
3379 fi
3380
3381 ac_exeext=$ac_cv_exeext
3382 echo "$as_me:$LINENO: result: $ac_file" >&5
3383 echo "${ECHO_T}$ac_file" >&6
3384
3385 # Check the compiler produces executables we can run.  If not, either
3386 # the compiler is broken, or we cross compile.
3387 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3388 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3389 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3390 # If not cross compiling, check that we can run a simple program.
3391 if test "$cross_compiling" != yes; then
3392   if { ac_try='./$ac_file'
3393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3394   (eval $ac_try) 2>&5
3395   ac_status=$?
3396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3397   (exit $ac_status); }; }; then
3398     cross_compiling=no
3399   else
3400     if test "$cross_compiling" = maybe; then
3401         cross_compiling=yes
3402     else
3403         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3404 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3405 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3406 If you meant to cross compile, use \`--host'.
3407 See \`config.log' for more details." >&5
3408 echo "$as_me: error: cannot run C compiled programs.
3409 If you meant to cross compile, use \`--host'.
3410 See \`config.log' for more details." >&2;}
3411    { (exit 1); exit 1; }; }; }
3412     fi
3413   fi
3414 fi
3415 echo "$as_me:$LINENO: result: yes" >&5
3416 echo "${ECHO_T}yes" >&6
3417
3418 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3419 ac_clean_files=$ac_clean_files_save
3420 # Check the compiler produces executables we can run.  If not, either
3421 # the compiler is broken, or we cross compile.
3422 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3423 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3424 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3425 echo "${ECHO_T}$cross_compiling" >&6
3426
3427 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3428 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3429 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3430   (eval $ac_link) 2>&5
3431   ac_status=$?
3432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3433   (exit $ac_status); }; then
3434   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3435 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3436 # work properly (i.e., refer to `conftest.exe'), while it won't with
3437 # `rm'.
3438 for ac_file in conftest.exe conftest conftest.*; do
3439   test -f "$ac_file" || continue
3440   case $ac_file in
3441     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3442     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3443           export ac_cv_exeext
3444           break;;
3445     * ) break;;
3446   esac
3447 done
3448 else
3449   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3450 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3451 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3452 See \`config.log' for more details." >&5
3453 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3454 See \`config.log' for more details." >&2;}
3455    { (exit 1); exit 1; }; }; }
3456 fi
3457
3458 rm -f conftest$ac_cv_exeext
3459 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3460 echo "${ECHO_T}$ac_cv_exeext" >&6
3461
3462 rm -f conftest.$ac_ext
3463 EXEEXT=$ac_cv_exeext
3464 ac_exeext=$EXEEXT
3465 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3466 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3467 if test "${ac_cv_objext+set}" = set; then
3468   echo $ECHO_N "(cached) $ECHO_C" >&6
3469 else
3470   cat >conftest.$ac_ext <<_ACEOF
3471 /* confdefs.h.  */
3472 _ACEOF
3473 cat confdefs.h >>conftest.$ac_ext
3474 cat >>conftest.$ac_ext <<_ACEOF
3475 /* end confdefs.h.  */
3476
3477 int
3478 main ()
3479 {
3480
3481   ;
3482   return 0;
3483 }
3484 _ACEOF
3485 rm -f conftest.o conftest.obj
3486 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3487   (eval $ac_compile) 2>&5
3488   ac_status=$?
3489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3490   (exit $ac_status); }; then
3491   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3492   case $ac_file in
3493     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3494     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3495        break;;
3496   esac
3497 done
3498 else
3499   echo "$as_me: failed program was:" >&5
3500 sed 's/^/| /' conftest.$ac_ext >&5
3501
3502 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3503 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3504 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3505 See \`config.log' for more details." >&5
3506 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3507 See \`config.log' for more details." >&2;}
3508    { (exit 1); exit 1; }; }; }
3509 fi
3510
3511 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3512 fi
3513 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3514 echo "${ECHO_T}$ac_cv_objext" >&6
3515 OBJEXT=$ac_cv_objext
3516 ac_objext=$OBJEXT
3517 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3518 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3519 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3520   echo $ECHO_N "(cached) $ECHO_C" >&6
3521 else
3522   cat >conftest.$ac_ext <<_ACEOF
3523 /* confdefs.h.  */
3524 _ACEOF
3525 cat confdefs.h >>conftest.$ac_ext
3526 cat >>conftest.$ac_ext <<_ACEOF
3527 /* end confdefs.h.  */
3528
3529 int
3530 main ()
3531 {
3532 #ifndef __GNUC__
3533        choke me
3534 #endif
3535
3536   ;
3537   return 0;
3538 }
3539 _ACEOF
3540 rm -f conftest.$ac_objext
3541 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3542   (eval $ac_compile) 2>conftest.er1
3543   ac_status=$?
3544   grep -v '^ *+' conftest.er1 >conftest.err
3545   rm -f conftest.er1
3546   cat conftest.err >&5
3547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3548   (exit $ac_status); } &&
3549          { ac_try='test -z "$ac_c_werror_flag"
3550                          || test ! -s conftest.err'
3551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3552   (eval $ac_try) 2>&5
3553   ac_status=$?
3554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3555   (exit $ac_status); }; } &&
3556          { ac_try='test -s conftest.$ac_objext'
3557   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3558   (eval $ac_try) 2>&5
3559   ac_status=$?
3560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3561   (exit $ac_status); }; }; then
3562   ac_compiler_gnu=yes
3563 else
3564   echo "$as_me: failed program was:" >&5
3565 sed 's/^/| /' conftest.$ac_ext >&5
3566
3567 ac_compiler_gnu=no
3568 fi
3569 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3570 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3571
3572 fi
3573 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3574 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3575 GCC=`test $ac_compiler_gnu = yes && echo yes`
3576 ac_test_CFLAGS=${CFLAGS+set}
3577 ac_save_CFLAGS=$CFLAGS
3578 CFLAGS="-g"
3579 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3580 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3581 if test "${ac_cv_prog_cc_g+set}" = set; then
3582   echo $ECHO_N "(cached) $ECHO_C" >&6
3583 else
3584   cat >conftest.$ac_ext <<_ACEOF
3585 /* confdefs.h.  */
3586 _ACEOF
3587 cat confdefs.h >>conftest.$ac_ext
3588 cat >>conftest.$ac_ext <<_ACEOF
3589 /* end confdefs.h.  */
3590
3591 int
3592 main ()
3593 {
3594
3595   ;
3596   return 0;
3597 }
3598 _ACEOF
3599 rm -f conftest.$ac_objext
3600 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3601   (eval $ac_compile) 2>conftest.er1
3602   ac_status=$?
3603   grep -v '^ *+' conftest.er1 >conftest.err
3604   rm -f conftest.er1
3605   cat conftest.err >&5
3606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3607   (exit $ac_status); } &&
3608          { ac_try='test -z "$ac_c_werror_flag"
3609                          || test ! -s conftest.err'
3610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3611   (eval $ac_try) 2>&5
3612   ac_status=$?
3613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3614   (exit $ac_status); }; } &&
3615          { ac_try='test -s conftest.$ac_objext'
3616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3617   (eval $ac_try) 2>&5
3618   ac_status=$?
3619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3620   (exit $ac_status); }; }; then
3621   ac_cv_prog_cc_g=yes
3622 else
3623   echo "$as_me: failed program was:" >&5
3624 sed 's/^/| /' conftest.$ac_ext >&5
3625
3626 ac_cv_prog_cc_g=no
3627 fi
3628 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3629 fi
3630 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3631 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3632 if test "$ac_test_CFLAGS" = set; then
3633   CFLAGS=$ac_save_CFLAGS
3634 elif test $ac_cv_prog_cc_g = yes; then
3635   if test "$GCC" = yes; then
3636     CFLAGS="-g -O2"
3637   else
3638     CFLAGS="-g"
3639   fi
3640 else
3641   if test "$GCC" = yes; then
3642     CFLAGS="-O2"
3643   else
3644     CFLAGS=
3645   fi
3646 fi
3647 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3648 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3649 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3650   echo $ECHO_N "(cached) $ECHO_C" >&6
3651 else
3652   ac_cv_prog_cc_stdc=no
3653 ac_save_CC=$CC
3654 cat >conftest.$ac_ext <<_ACEOF
3655 /* confdefs.h.  */
3656 _ACEOF
3657 cat confdefs.h >>conftest.$ac_ext
3658 cat >>conftest.$ac_ext <<_ACEOF
3659 /* end confdefs.h.  */
3660 #include <stdarg.h>
3661 #include <stdio.h>
3662 #include <sys/types.h>
3663 #include <sys/stat.h>
3664 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3665 struct buf { int x; };
3666 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3667 static char *e (p, i)
3668      char **p;
3669      int i;
3670 {
3671   return p[i];
3672 }
3673 static char *f (char * (*g) (char **, int), char **p, ...)
3674 {
3675   char *s;
3676   va_list v;
3677   va_start (v,p);
3678   s = g (p, va_arg (v,int));
3679   va_end (v);
3680   return s;
3681 }
3682
3683 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3684    function prototypes and stuff, but not '\xHH' hex character constants.
3685    These don't provoke an error unfortunately, instead are silently treated
3686    as 'x'.  The following induces an error, until -std1 is added to get
3687    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3688    array size at least.  It's necessary to write '\x00'==0 to get something
3689    that's true only with -std1.  */
3690 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3691
3692 int test (int i, double x);
3693 struct s1 {int (*f) (int a);};
3694 struct s2 {int (*f) (double a);};
3695 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3696 int argc;
3697 char **argv;
3698 int
3699 main ()
3700 {
3701 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3702   ;
3703   return 0;
3704 }
3705 _ACEOF
3706 # Don't try gcc -ansi; that turns off useful extensions and
3707 # breaks some systems' header files.
3708 # AIX                   -qlanglvl=ansi
3709 # Ultrix and OSF/1      -std1
3710 # HP-UX 10.20 and later -Ae
3711 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3712 # SVR4                  -Xc -D__EXTENSIONS__
3713 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3714 do
3715   CC="$ac_save_CC $ac_arg"
3716   rm -f conftest.$ac_objext
3717 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3718   (eval $ac_compile) 2>conftest.er1
3719   ac_status=$?
3720   grep -v '^ *+' conftest.er1 >conftest.err
3721   rm -f conftest.er1
3722   cat conftest.err >&5
3723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3724   (exit $ac_status); } &&
3725          { ac_try='test -z "$ac_c_werror_flag"
3726                          || test ! -s conftest.err'
3727   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3728   (eval $ac_try) 2>&5
3729   ac_status=$?
3730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3731   (exit $ac_status); }; } &&
3732          { ac_try='test -s conftest.$ac_objext'
3733   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3734   (eval $ac_try) 2>&5
3735   ac_status=$?
3736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3737   (exit $ac_status); }; }; then
3738   ac_cv_prog_cc_stdc=$ac_arg
3739 break
3740 else
3741   echo "$as_me: failed program was:" >&5
3742 sed 's/^/| /' conftest.$ac_ext >&5
3743
3744 fi
3745 rm -f conftest.err conftest.$ac_objext
3746 done
3747 rm -f conftest.$ac_ext conftest.$ac_objext
3748 CC=$ac_save_CC
3749
3750 fi
3751
3752 case "x$ac_cv_prog_cc_stdc" in
3753   x|xno)
3754     echo "$as_me:$LINENO: result: none needed" >&5
3755 echo "${ECHO_T}none needed" >&6 ;;
3756   *)
3757     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3758 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3759     CC="$CC $ac_cv_prog_cc_stdc" ;;
3760 esac
3761
3762 # Some people use a C++ compiler to compile C.  Since we use `exit',
3763 # in C++ we need to declare it.  In case someone uses the same compiler
3764 # for both compiling C and C++ we need to have the C++ compiler decide
3765 # the declaration of exit, since it's the most demanding environment.
3766 cat >conftest.$ac_ext <<_ACEOF
3767 #ifndef __cplusplus
3768   choke me
3769 #endif
3770 _ACEOF
3771 rm -f conftest.$ac_objext
3772 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3773   (eval $ac_compile) 2>conftest.er1
3774   ac_status=$?
3775   grep -v '^ *+' conftest.er1 >conftest.err
3776   rm -f conftest.er1
3777   cat conftest.err >&5
3778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3779   (exit $ac_status); } &&
3780          { ac_try='test -z "$ac_c_werror_flag"
3781                          || test ! -s conftest.err'
3782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3783   (eval $ac_try) 2>&5
3784   ac_status=$?
3785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3786   (exit $ac_status); }; } &&
3787          { ac_try='test -s conftest.$ac_objext'
3788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3789   (eval $ac_try) 2>&5
3790   ac_status=$?
3791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3792   (exit $ac_status); }; }; then
3793   for ac_declaration in \
3794    '' \
3795    'extern "C" void std::exit (int) throw (); using std::exit;' \
3796    'extern "C" void std::exit (int); using std::exit;' \
3797    'extern "C" void exit (int) throw ();' \
3798    'extern "C" void exit (int);' \
3799    'void exit (int);'
3800 do
3801   cat >conftest.$ac_ext <<_ACEOF
3802 /* confdefs.h.  */
3803 _ACEOF
3804 cat confdefs.h >>conftest.$ac_ext
3805 cat >>conftest.$ac_ext <<_ACEOF
3806 /* end confdefs.h.  */
3807 $ac_declaration
3808 #include <stdlib.h>
3809 int
3810 main ()
3811 {
3812 exit (42);
3813   ;
3814   return 0;
3815 }
3816 _ACEOF
3817 rm -f conftest.$ac_objext
3818 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3819   (eval $ac_compile) 2>conftest.er1
3820   ac_status=$?
3821   grep -v '^ *+' conftest.er1 >conftest.err
3822   rm -f conftest.er1
3823   cat conftest.err >&5
3824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3825   (exit $ac_status); } &&
3826          { ac_try='test -z "$ac_c_werror_flag"
3827                          || test ! -s conftest.err'
3828   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3829   (eval $ac_try) 2>&5
3830   ac_status=$?
3831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3832   (exit $ac_status); }; } &&
3833          { ac_try='test -s conftest.$ac_objext'
3834   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3835   (eval $ac_try) 2>&5
3836   ac_status=$?
3837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3838   (exit $ac_status); }; }; then
3839   :
3840 else
3841   echo "$as_me: failed program was:" >&5
3842 sed 's/^/| /' conftest.$ac_ext >&5
3843
3844 continue
3845 fi
3846 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3847   cat >conftest.$ac_ext <<_ACEOF
3848 /* confdefs.h.  */
3849 _ACEOF
3850 cat confdefs.h >>conftest.$ac_ext
3851 cat >>conftest.$ac_ext <<_ACEOF
3852 /* end confdefs.h.  */
3853 $ac_declaration
3854 int
3855 main ()
3856 {
3857 exit (42);
3858   ;
3859   return 0;
3860 }
3861 _ACEOF
3862 rm -f conftest.$ac_objext
3863 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3864   (eval $ac_compile) 2>conftest.er1
3865   ac_status=$?
3866   grep -v '^ *+' conftest.er1 >conftest.err
3867   rm -f conftest.er1
3868   cat conftest.err >&5
3869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3870   (exit $ac_status); } &&
3871          { ac_try='test -z "$ac_c_werror_flag"
3872                          || test ! -s conftest.err'
3873   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3874   (eval $ac_try) 2>&5
3875   ac_status=$?
3876   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3877   (exit $ac_status); }; } &&
3878          { ac_try='test -s conftest.$ac_objext'
3879   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3880   (eval $ac_try) 2>&5
3881   ac_status=$?
3882   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3883   (exit $ac_status); }; }; then
3884   break
3885 else
3886   echo "$as_me: failed program was:" >&5
3887 sed 's/^/| /' conftest.$ac_ext >&5
3888
3889 fi
3890 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3891 done
3892 rm -f conftest*
3893 if test -n "$ac_declaration"; then
3894   echo '#ifdef __cplusplus' >>confdefs.h
3895   echo $ac_declaration      >>confdefs.h
3896   echo '#endif'             >>confdefs.h
3897 fi
3898
3899 else
3900   echo "$as_me: failed program was:" >&5
3901 sed 's/^/| /' conftest.$ac_ext >&5
3902
3903 fi
3904 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3905 ac_ext=c
3906 ac_cpp='$CPP $CPPFLAGS'
3907 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3908 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3909 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3910
3911 ac_ext=cc
3912 ac_cpp='$CXXCPP $CPPFLAGS'
3913 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3914 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3915 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3916 if test -n "$ac_tool_prefix"; then
3917   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3918   do
3919     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3920 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3921 echo "$as_me:$LINENO: checking for $ac_word" >&5
3922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3923 if test "${ac_cv_prog_CXX+set}" = set; then
3924   echo $ECHO_N "(cached) $ECHO_C" >&6
3925 else
3926   if test -n "$CXX"; then
3927   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3928 else
3929 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3930 for as_dir in $PATH
3931 do
3932   IFS=$as_save_IFS
3933   test -z "$as_dir" && as_dir=.
3934   for ac_exec_ext in '' $ac_executable_extensions; do
3935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3936     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3938     break 2
3939   fi
3940 done
3941 done
3942
3943 fi
3944 fi
3945 CXX=$ac_cv_prog_CXX
3946 if test -n "$CXX"; then
3947   echo "$as_me:$LINENO: result: $CXX" >&5
3948 echo "${ECHO_T}$CXX" >&6
3949 else
3950   echo "$as_me:$LINENO: result: no" >&5
3951 echo "${ECHO_T}no" >&6
3952 fi
3953
3954     test -n "$CXX" && break
3955   done
3956 fi
3957 if test -z "$CXX"; then
3958   ac_ct_CXX=$CXX
3959   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3960 do
3961   # Extract the first word of "$ac_prog", so it can be a program name with args.
3962 set dummy $ac_prog; ac_word=$2
3963 echo "$as_me:$LINENO: checking for $ac_word" >&5
3964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3965 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3966   echo $ECHO_N "(cached) $ECHO_C" >&6
3967 else
3968   if test -n "$ac_ct_CXX"; then
3969   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3970 else
3971 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3972 for as_dir in $PATH
3973 do
3974   IFS=$as_save_IFS
3975   test -z "$as_dir" && as_dir=.
3976   for ac_exec_ext in '' $ac_executable_extensions; do
3977   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3978     ac_cv_prog_ac_ct_CXX="$ac_prog"
3979     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3980     break 2
3981   fi
3982 done
3983 done
3984
3985 fi
3986 fi
3987 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3988 if test -n "$ac_ct_CXX"; then
3989   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3990 echo "${ECHO_T}$ac_ct_CXX" >&6
3991 else
3992   echo "$as_me:$LINENO: result: no" >&5
3993 echo "${ECHO_T}no" >&6
3994 fi
3995
3996   test -n "$ac_ct_CXX" && break
3997 done
3998 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3999
4000   CXX=$ac_ct_CXX
4001 fi
4002
4003
4004 # Provide some information about the compiler.
4005 echo "$as_me:$LINENO:" \
4006      "checking for C++ compiler version" >&5
4007 ac_compiler=`set X $ac_compile; echo $2`
4008 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4009   (eval $ac_compiler --version </dev/null >&5) 2>&5
4010   ac_status=$?
4011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4012   (exit $ac_status); }
4013 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4014   (eval $ac_compiler -v </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
4024 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4025 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4026 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4027   echo $ECHO_N "(cached) $ECHO_C" >&6
4028 else
4029   cat >conftest.$ac_ext <<_ACEOF
4030 /* confdefs.h.  */
4031 _ACEOF
4032 cat confdefs.h >>conftest.$ac_ext
4033 cat >>conftest.$ac_ext <<_ACEOF
4034 /* end confdefs.h.  */
4035
4036 int
4037 main ()
4038 {
4039 #ifndef __GNUC__
4040        choke me
4041 #endif
4042
4043   ;
4044   return 0;
4045 }
4046 _ACEOF
4047 rm -f conftest.$ac_objext
4048 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4049   (eval $ac_compile) 2>conftest.er1
4050   ac_status=$?
4051   grep -v '^ *+' conftest.er1 >conftest.err
4052   rm -f conftest.er1
4053   cat conftest.err >&5
4054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4055   (exit $ac_status); } &&
4056          { ac_try='test -z "$ac_cxx_werror_flag"
4057                          || test ! -s conftest.err'
4058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4059   (eval $ac_try) 2>&5
4060   ac_status=$?
4061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4062   (exit $ac_status); }; } &&
4063          { ac_try='test -s conftest.$ac_objext'
4064   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4065   (eval $ac_try) 2>&5
4066   ac_status=$?
4067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4068   (exit $ac_status); }; }; then
4069   ac_compiler_gnu=yes
4070 else
4071   echo "$as_me: failed program was:" >&5
4072 sed 's/^/| /' conftest.$ac_ext >&5
4073
4074 ac_compiler_gnu=no
4075 fi
4076 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4077 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4078
4079 fi
4080 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4081 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4082 GXX=`test $ac_compiler_gnu = yes && echo yes`
4083 ac_test_CXXFLAGS=${CXXFLAGS+set}
4084 ac_save_CXXFLAGS=$CXXFLAGS
4085 CXXFLAGS="-g"
4086 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4087 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4088 if test "${ac_cv_prog_cxx_g+set}" = set; then
4089   echo $ECHO_N "(cached) $ECHO_C" >&6
4090 else
4091   cat >conftest.$ac_ext <<_ACEOF
4092 /* confdefs.h.  */
4093 _ACEOF
4094 cat confdefs.h >>conftest.$ac_ext
4095 cat >>conftest.$ac_ext <<_ACEOF
4096 /* end confdefs.h.  */
4097
4098 int
4099 main ()
4100 {
4101
4102   ;
4103   return 0;
4104 }
4105 _ACEOF
4106 rm -f conftest.$ac_objext
4107 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4108   (eval $ac_compile) 2>conftest.er1
4109   ac_status=$?
4110   grep -v '^ *+' conftest.er1 >conftest.err
4111   rm -f conftest.er1
4112   cat conftest.err >&5
4113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4114   (exit $ac_status); } &&
4115          { ac_try='test -z "$ac_cxx_werror_flag"
4116                          || test ! -s conftest.err'
4117   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4118   (eval $ac_try) 2>&5
4119   ac_status=$?
4120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4121   (exit $ac_status); }; } &&
4122          { ac_try='test -s conftest.$ac_objext'
4123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4124   (eval $ac_try) 2>&5
4125   ac_status=$?
4126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4127   (exit $ac_status); }; }; then
4128   ac_cv_prog_cxx_g=yes
4129 else
4130   echo "$as_me: failed program was:" >&5
4131 sed 's/^/| /' conftest.$ac_ext >&5
4132
4133 ac_cv_prog_cxx_g=no
4134 fi
4135 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4136 fi
4137 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4138 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4139 if test "$ac_test_CXXFLAGS" = set; then
4140   CXXFLAGS=$ac_save_CXXFLAGS
4141 elif test $ac_cv_prog_cxx_g = yes; then
4142   if test "$GXX" = yes; then
4143     CXXFLAGS="-g -O2"
4144   else
4145     CXXFLAGS="-g"
4146   fi
4147 else
4148   if test "$GXX" = yes; then
4149     CXXFLAGS="-O2"
4150   else
4151     CXXFLAGS=
4152   fi
4153 fi
4154 for ac_declaration in \
4155    '' \
4156    'extern "C" void std::exit (int) throw (); using std::exit;' \
4157    'extern "C" void std::exit (int); using std::exit;' \
4158    'extern "C" void exit (int) throw ();' \
4159    'extern "C" void exit (int);' \
4160    'void exit (int);'
4161 do
4162   cat >conftest.$ac_ext <<_ACEOF
4163 /* confdefs.h.  */
4164 _ACEOF
4165 cat confdefs.h >>conftest.$ac_ext
4166 cat >>conftest.$ac_ext <<_ACEOF
4167 /* end confdefs.h.  */
4168 $ac_declaration
4169 #include <stdlib.h>
4170 int
4171 main ()
4172 {
4173 exit (42);
4174   ;
4175   return 0;
4176 }
4177 _ACEOF
4178 rm -f conftest.$ac_objext
4179 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4180   (eval $ac_compile) 2>conftest.er1
4181   ac_status=$?
4182   grep -v '^ *+' conftest.er1 >conftest.err
4183   rm -f conftest.er1
4184   cat conftest.err >&5
4185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4186   (exit $ac_status); } &&
4187          { ac_try='test -z "$ac_cxx_werror_flag"
4188                          || test ! -s conftest.err'
4189   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4190   (eval $ac_try) 2>&5
4191   ac_status=$?
4192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4193   (exit $ac_status); }; } &&
4194          { ac_try='test -s conftest.$ac_objext'
4195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4196   (eval $ac_try) 2>&5
4197   ac_status=$?
4198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4199   (exit $ac_status); }; }; then
4200   :
4201 else
4202   echo "$as_me: failed program was:" >&5
4203 sed 's/^/| /' conftest.$ac_ext >&5
4204
4205 continue
4206 fi
4207 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4208   cat >conftest.$ac_ext <<_ACEOF
4209 /* confdefs.h.  */
4210 _ACEOF
4211 cat confdefs.h >>conftest.$ac_ext
4212 cat >>conftest.$ac_ext <<_ACEOF
4213 /* end confdefs.h.  */
4214 $ac_declaration
4215 int
4216 main ()
4217 {
4218 exit (42);
4219   ;
4220   return 0;
4221 }
4222 _ACEOF
4223 rm -f conftest.$ac_objext
4224 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4225   (eval $ac_compile) 2>conftest.er1
4226   ac_status=$?
4227   grep -v '^ *+' conftest.er1 >conftest.err
4228   rm -f conftest.er1
4229   cat conftest.err >&5
4230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4231   (exit $ac_status); } &&
4232          { ac_try='test -z "$ac_cxx_werror_flag"
4233                          || test ! -s conftest.err'
4234   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4235   (eval $ac_try) 2>&5
4236   ac_status=$?
4237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4238   (exit $ac_status); }; } &&
4239          { ac_try='test -s conftest.$ac_objext'
4240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4241   (eval $ac_try) 2>&5
4242   ac_status=$?
4243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4244   (exit $ac_status); }; }; then
4245   break
4246 else
4247   echo "$as_me: failed program was:" >&5
4248 sed 's/^/| /' conftest.$ac_ext >&5
4249
4250 fi
4251 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4252 done
4253 rm -f conftest*
4254 if test -n "$ac_declaration"; then
4255   echo '#ifdef __cplusplus' >>confdefs.h
4256   echo $ac_declaration      >>confdefs.h
4257   echo '#endif'             >>confdefs.h
4258 fi
4259
4260 ac_ext=c
4261 ac_cpp='$CPP $CPPFLAGS'
4262 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4263 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4264 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4265
4266
4267 # We must set the default linker to the linker used by gcc for the correct
4268 # operation of libtool.  If LD is not defined and we are using gcc, try to
4269 # set the LD default to the ld used by gcc.
4270 if test -z "$LD"; then
4271   if test "$GCC" = yes; then
4272     case $build in
4273     *-*-mingw*)
4274       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4275     *)
4276       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4277     esac
4278     case $gcc_prog_ld in
4279     # Accept absolute paths.
4280     [\\/]* | [A-Za-z]:[\\/]*)
4281       LD="$gcc_prog_ld" ;;
4282     esac
4283   fi
4284 fi
4285
4286
4287
4288
4289 if test -n "$ac_tool_prefix"; then
4290   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4291 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4292 echo "$as_me:$LINENO: checking for $ac_word" >&5
4293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4294 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4295   echo $ECHO_N "(cached) $ECHO_C" >&6
4296 else
4297   if test -n "$GNATBIND"; then
4298   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4299 else
4300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4301 for as_dir in $PATH
4302 do
4303   IFS=$as_save_IFS
4304   test -z "$as_dir" && as_dir=.
4305   for ac_exec_ext in '' $ac_executable_extensions; do
4306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4307     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4309     break 2
4310   fi
4311 done
4312 done
4313
4314 fi
4315 fi
4316 GNATBIND=$ac_cv_prog_GNATBIND
4317 if test -n "$GNATBIND"; then
4318   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4319 echo "${ECHO_T}$GNATBIND" >&6
4320 else
4321   echo "$as_me:$LINENO: result: no" >&5
4322 echo "${ECHO_T}no" >&6
4323 fi
4324
4325 fi
4326 if test -z "$ac_cv_prog_GNATBIND"; then
4327   ac_ct_GNATBIND=$GNATBIND
4328   # Extract the first word of "gnatbind", so it can be a program name with args.
4329 set dummy gnatbind; ac_word=$2
4330 echo "$as_me:$LINENO: checking for $ac_word" >&5
4331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4332 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4333   echo $ECHO_N "(cached) $ECHO_C" >&6
4334 else
4335   if test -n "$ac_ct_GNATBIND"; then
4336   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4337 else
4338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4339 for as_dir in $PATH
4340 do
4341   IFS=$as_save_IFS
4342   test -z "$as_dir" && as_dir=.
4343   for ac_exec_ext in '' $ac_executable_extensions; do
4344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4345     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4347     break 2
4348   fi
4349 done
4350 done
4351
4352   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4353 fi
4354 fi
4355 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4356 if test -n "$ac_ct_GNATBIND"; then
4357   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4358 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4359 else
4360   echo "$as_me:$LINENO: result: no" >&5
4361 echo "${ECHO_T}no" >&6
4362 fi
4363
4364   GNATBIND=$ac_ct_GNATBIND
4365 else
4366   GNATBIND="$ac_cv_prog_GNATBIND"
4367 fi
4368
4369 if test -n "$ac_tool_prefix"; then
4370   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4371 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4372 echo "$as_me:$LINENO: checking for $ac_word" >&5
4373 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4374 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4375   echo $ECHO_N "(cached) $ECHO_C" >&6
4376 else
4377   if test -n "$GNATMAKE"; then
4378   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4379 else
4380 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4381 for as_dir in $PATH
4382 do
4383   IFS=$as_save_IFS
4384   test -z "$as_dir" && as_dir=.
4385   for ac_exec_ext in '' $ac_executable_extensions; do
4386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4387     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4389     break 2
4390   fi
4391 done
4392 done
4393
4394 fi
4395 fi
4396 GNATMAKE=$ac_cv_prog_GNATMAKE
4397 if test -n "$GNATMAKE"; then
4398   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4399 echo "${ECHO_T}$GNATMAKE" >&6
4400 else
4401   echo "$as_me:$LINENO: result: no" >&5
4402 echo "${ECHO_T}no" >&6
4403 fi
4404
4405 fi
4406 if test -z "$ac_cv_prog_GNATMAKE"; then
4407   ac_ct_GNATMAKE=$GNATMAKE
4408   # Extract the first word of "gnatmake", so it can be a program name with args.
4409 set dummy gnatmake; ac_word=$2
4410 echo "$as_me:$LINENO: checking for $ac_word" >&5
4411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4412 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4413   echo $ECHO_N "(cached) $ECHO_C" >&6
4414 else
4415   if test -n "$ac_ct_GNATMAKE"; then
4416   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4417 else
4418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4419 for as_dir in $PATH
4420 do
4421   IFS=$as_save_IFS
4422   test -z "$as_dir" && as_dir=.
4423   for ac_exec_ext in '' $ac_executable_extensions; do
4424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4425     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4427     break 2
4428   fi
4429 done
4430 done
4431
4432   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4433 fi
4434 fi
4435 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4436 if test -n "$ac_ct_GNATMAKE"; then
4437   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4438 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4439 else
4440   echo "$as_me:$LINENO: result: no" >&5
4441 echo "${ECHO_T}no" >&6
4442 fi
4443
4444   GNATMAKE=$ac_ct_GNATMAKE
4445 else
4446   GNATMAKE="$ac_cv_prog_GNATMAKE"
4447 fi
4448
4449 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4450 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4451 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4452   echo $ECHO_N "(cached) $ECHO_C" >&6
4453 else
4454   cat >conftest.adb <<EOF
4455 procedure conftest is begin null; end conftest;
4456 EOF
4457 acx_cv_cc_gcc_supports_ada=no
4458 # There is a bug in old released versions of GCC which causes the
4459 # driver to exit successfully when the appropriate language module
4460 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4461 # Therefore we must check for the error message as well as an
4462 # unsuccessful exit.
4463 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4464 # given a .adb file, but produce no object file.  So we must check
4465 # if an object file was really produced to guard against this.
4466 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4467 if test x"$errors" = x && test -f conftest.$ac_objext; then
4468   acx_cv_cc_gcc_supports_ada=yes
4469 fi
4470 rm -f conftest.*
4471 fi
4472 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4473 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4474
4475 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4476   have_gnat=yes
4477 else
4478   have_gnat=no
4479 fi
4480
4481 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4482 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4483 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4484   echo $ECHO_N "(cached) $ECHO_C" >&6
4485 else
4486    echo abfoo >t1
4487   echo cdfoo >t2
4488   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4489   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4490     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4491       :
4492     else
4493       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4494     fi
4495   fi
4496   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4497     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4498       :
4499     else
4500       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4501     fi
4502   fi
4503   rm t1 t2
4504
4505 fi
4506 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4507 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4508 do_compare="$gcc_cv_prog_cmp_skip"
4509
4510
4511
4512 # See if we are building gcc with C++.
4513 # Check whether --enable-build-with-cxx or --disable-build-with-cxx was given.
4514 if test "${enable_build_with_cxx+set}" = set; then
4515   enableval="$enable_build_with_cxx"
4516   ENABLE_BUILD_WITH_CXX=$enableval
4517 else
4518   ENABLE_BUILD_WITH_CXX=no
4519 fi;
4520
4521 # Check for GMP, MPFR and MPC
4522 gmplibs="-lmpfr -lgmp"
4523 gmpinc=
4524 have_gmp=no
4525 mpclibs=-lmpc
4526 mpcinc=
4527 have_mpc=no
4528
4529 # Specify a location for mpc
4530 # check for this first so it ends up on the link line before mpfr.
4531
4532 # Check whether --with-mpc or --without-mpc was given.
4533 if test "${with_mpc+set}" = set; then
4534   withval="$with_mpc"
4535
4536 fi;
4537
4538 # Check whether --with-mpc_include or --without-mpc_include was given.
4539 if test "${with_mpc_include+set}" = set; then
4540   withval="$with_mpc_include"
4541
4542 fi;
4543
4544 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4545 if test "${with_mpc_lib+set}" = set; then
4546   withval="$with_mpc_lib"
4547
4548 fi;
4549
4550 if test "x$with_mpc" != x; then
4551   mpclibs="-L$with_mpc/lib -lmpc"
4552   mpcinc="-I$with_mpc/include $mpcinc"
4553 fi
4554 if test "x$with_mpc_include" != x; then
4555   mpcinc="-I$with_mpc_include $mpcinc"
4556 fi
4557 if test "x$with_mpc_lib" != x; then
4558   mpclibs="-L$with_mpc_lib -lmpc"
4559 fi
4560 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4561   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4562   mpcinc='-I$$s/mpc/src '"$mpcinc"
4563   # Do not test the mpc version.  Assume that it is sufficient, since
4564   # it is in the source tree, and the library has not been built yet
4565   # but it would be included on the link line in the version check below
4566   # hence making the test fail.
4567   have_mpc=yes
4568 fi
4569
4570 # Specify a location for mpfr
4571 # check for this first so it ends up on the link line before gmp.
4572
4573 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4574 if test "${with_mpfr_dir+set}" = set; then
4575   withval="$with_mpfr_dir"
4576   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4577 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4578 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4579 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4580    { (exit 1); exit 1; }; }
4581 fi;
4582
4583
4584 # Check whether --with-mpfr or --without-mpfr was given.
4585 if test "${with_mpfr+set}" = set; then
4586   withval="$with_mpfr"
4587
4588 fi;
4589
4590 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4591 if test "${with_mpfr_include+set}" = set; then
4592   withval="$with_mpfr_include"
4593
4594 fi;
4595
4596 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4597 if test "${with_mpfr_lib+set}" = set; then
4598   withval="$with_mpfr_lib"
4599
4600 fi;
4601
4602 if test "x$with_mpfr" != x; then
4603   gmplibs="-L$with_mpfr/lib $gmplibs"
4604   gmpinc="-I$with_mpfr/include"
4605 fi
4606 if test "x$with_mpfr_include" != x; then
4607   gmpinc="-I$with_mpfr_include"
4608 fi
4609 if test "x$with_mpfr_lib" != x; then
4610   gmplibs="-L$with_mpfr_lib $gmplibs"
4611 fi
4612 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4613   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4614   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4615   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4616   # Do not test the mpfr version.  Assume that it is sufficient, since
4617   # it is in the source tree, and the library has not been built yet
4618   # but it would be included on the link line in the version check below
4619   # hence making the test fail.
4620   have_gmp=yes
4621 fi
4622
4623 # Specify a location for gmp
4624
4625 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4626 if test "${with_gmp_dir+set}" = set; then
4627   withval="$with_gmp_dir"
4628   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4629 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4630 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4631 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4632    { (exit 1); exit 1; }; }
4633 fi;
4634
4635
4636 # Check whether --with-gmp or --without-gmp was given.
4637 if test "${with_gmp+set}" = set; then
4638   withval="$with_gmp"
4639
4640 fi;
4641
4642 # Check whether --with-gmp_include or --without-gmp_include was given.
4643 if test "${with_gmp_include+set}" = set; then
4644   withval="$with_gmp_include"
4645
4646 fi;
4647
4648 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4649 if test "${with_gmp_lib+set}" = set; then
4650   withval="$with_gmp_lib"
4651
4652 fi;
4653
4654
4655 if test "x$with_gmp" != x; then
4656   gmplibs="-L$with_gmp/lib $gmplibs"
4657   gmpinc="-I$with_gmp/include $gmpinc"
4658 fi
4659 if test "x$with_gmp_include" != x; then
4660   gmpinc="-I$with_gmp_include $gmpinc"
4661 fi
4662 if test "x$with_gmp_lib" != x; then
4663   gmplibs="-L$with_gmp_lib $gmplibs"
4664 fi
4665 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4666   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4667   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4668   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4669   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4670   # Do not test the gmp version.  Assume that it is sufficient, since
4671   # it is in the source tree, and the library has not been built yet
4672   # but it would be included on the link line in the version check below
4673   # hence making the test fail.
4674   have_gmp=yes
4675 fi
4676
4677 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4678   have_gmp=yes
4679   saved_CFLAGS="$CFLAGS"
4680   CFLAGS="$CFLAGS $gmpinc"
4681   # Check GMP actually works
4682   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4683 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4684
4685 cat >conftest.$ac_ext <<_ACEOF
4686 /* confdefs.h.  */
4687 _ACEOF
4688 cat confdefs.h >>conftest.$ac_ext
4689 cat >>conftest.$ac_ext <<_ACEOF
4690 /* end confdefs.h.  */
4691 #include "gmp.h"
4692 int
4693 main ()
4694 {
4695
4696   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4697   choke me
4698   #endif
4699
4700   ;
4701   return 0;
4702 }
4703 _ACEOF
4704 rm -f conftest.$ac_objext
4705 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4706   (eval $ac_compile) 2>conftest.er1
4707   ac_status=$?
4708   grep -v '^ *+' conftest.er1 >conftest.err
4709   rm -f conftest.er1
4710   cat conftest.err >&5
4711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4712   (exit $ac_status); } &&
4713          { ac_try='test -z "$ac_c_werror_flag"
4714                          || test ! -s conftest.err'
4715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4716   (eval $ac_try) 2>&5
4717   ac_status=$?
4718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4719   (exit $ac_status); }; } &&
4720          { ac_try='test -s conftest.$ac_objext'
4721   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4722   (eval $ac_try) 2>&5
4723   ac_status=$?
4724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4725   (exit $ac_status); }; }; then
4726   echo "$as_me:$LINENO: result: yes" >&5
4727 echo "${ECHO_T}yes" >&6
4728 else
4729   echo "$as_me: failed program was:" >&5
4730 sed 's/^/| /' conftest.$ac_ext >&5
4731
4732 echo "$as_me:$LINENO: result: no" >&5
4733 echo "${ECHO_T}no" >&6; have_gmp=no
4734 fi
4735 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4736
4737   # If we have GMP, check the MPFR version.
4738   if test x"$have_gmp" = xyes; then
4739         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4740 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4741     cat >conftest.$ac_ext <<_ACEOF
4742 /* confdefs.h.  */
4743 _ACEOF
4744 cat confdefs.h >>conftest.$ac_ext
4745 cat >>conftest.$ac_ext <<_ACEOF
4746 /* end confdefs.h.  */
4747 #include <gmp.h>
4748     #include <mpfr.h>
4749 int
4750 main ()
4751 {
4752
4753     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4754     choke me
4755     #endif
4756
4757   ;
4758   return 0;
4759 }
4760 _ACEOF
4761 rm -f conftest.$ac_objext
4762 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4763   (eval $ac_compile) 2>conftest.er1
4764   ac_status=$?
4765   grep -v '^ *+' conftest.er1 >conftest.err
4766   rm -f conftest.er1
4767   cat conftest.err >&5
4768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4769   (exit $ac_status); } &&
4770          { ac_try='test -z "$ac_c_werror_flag"
4771                          || test ! -s conftest.err'
4772   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4773   (eval $ac_try) 2>&5
4774   ac_status=$?
4775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4776   (exit $ac_status); }; } &&
4777          { ac_try='test -s conftest.$ac_objext'
4778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4779   (eval $ac_try) 2>&5
4780   ac_status=$?
4781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4782   (exit $ac_status); }; }; then
4783   cat >conftest.$ac_ext <<_ACEOF
4784 /* confdefs.h.  */
4785 _ACEOF
4786 cat confdefs.h >>conftest.$ac_ext
4787 cat >>conftest.$ac_ext <<_ACEOF
4788 /* end confdefs.h.  */
4789 #include <gmp.h>
4790     #include <mpfr.h>
4791 int
4792 main ()
4793 {
4794
4795     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4796     choke me
4797     #endif
4798
4799   ;
4800   return 0;
4801 }
4802 _ACEOF
4803 rm -f conftest.$ac_objext
4804 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4805   (eval $ac_compile) 2>conftest.er1
4806   ac_status=$?
4807   grep -v '^ *+' conftest.er1 >conftest.err
4808   rm -f conftest.er1
4809   cat conftest.err >&5
4810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4811   (exit $ac_status); } &&
4812          { ac_try='test -z "$ac_c_werror_flag"
4813                          || test ! -s conftest.err'
4814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4815   (eval $ac_try) 2>&5
4816   ac_status=$?
4817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4818   (exit $ac_status); }; } &&
4819          { ac_try='test -s conftest.$ac_objext'
4820   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4821   (eval $ac_try) 2>&5
4822   ac_status=$?
4823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4824   (exit $ac_status); }; }; then
4825   echo "$as_me:$LINENO: result: yes" >&5
4826 echo "${ECHO_T}yes" >&6
4827 else
4828   echo "$as_me: failed program was:" >&5
4829 sed 's/^/| /' conftest.$ac_ext >&5
4830
4831 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4832 echo "${ECHO_T}buggy but acceptable" >&6
4833 fi
4834 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4835 else
4836   echo "$as_me: failed program was:" >&5
4837 sed 's/^/| /' conftest.$ac_ext >&5
4838
4839 echo "$as_me:$LINENO: result: no" >&5
4840 echo "${ECHO_T}no" >&6; have_gmp=no
4841 fi
4842 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4843   fi
4844
4845   # Check for the MPC header version.
4846   if test x"$have_mpc" != xyes ; then
4847     CFLAGS="$CFLAGS $mpcinc"
4848     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4849 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4850     cat >conftest.$ac_ext <<_ACEOF
4851 /* confdefs.h.  */
4852 _ACEOF
4853 cat confdefs.h >>conftest.$ac_ext
4854 cat >>conftest.$ac_ext <<_ACEOF
4855 /* end confdefs.h.  */
4856 #include <mpc.h>
4857 int
4858 main ()
4859 {
4860
4861     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4862     choke me
4863     #endif
4864
4865   ;
4866   return 0;
4867 }
4868 _ACEOF
4869 rm -f conftest.$ac_objext
4870 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4871   (eval $ac_compile) 2>conftest.er1
4872   ac_status=$?
4873   grep -v '^ *+' conftest.er1 >conftest.err
4874   rm -f conftest.er1
4875   cat conftest.err >&5
4876   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4877   (exit $ac_status); } &&
4878          { ac_try='test -z "$ac_c_werror_flag"
4879                          || test ! -s conftest.err'
4880   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4881   (eval $ac_try) 2>&5
4882   ac_status=$?
4883   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4884   (exit $ac_status); }; } &&
4885          { ac_try='test -s conftest.$ac_objext'
4886   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4887   (eval $ac_try) 2>&5
4888   ac_status=$?
4889   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4890   (exit $ac_status); }; }; then
4891   echo "$as_me:$LINENO: result: yes" >&5
4892 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4893 else
4894   echo "$as_me: failed program was:" >&5
4895 sed 's/^/| /' conftest.$ac_ext >&5
4896
4897 echo "$as_me:$LINENO: result: no" >&5
4898 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4899 fi
4900 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4901   fi
4902
4903   # Now check the MPFR library.
4904   if test x"$have_gmp" = xyes; then
4905     saved_LIBS="$LIBS"
4906     LIBS="$LIBS $gmplibs"
4907     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4908 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4909     cat >conftest.$ac_ext <<_ACEOF
4910 /* confdefs.h.  */
4911 _ACEOF
4912 cat confdefs.h >>conftest.$ac_ext
4913 cat >>conftest.$ac_ext <<_ACEOF
4914 /* end confdefs.h.  */
4915 #include <gmp.h>
4916     #include <mpfr.h>
4917 int
4918 main ()
4919 {
4920
4921     mpfr_t n;
4922     mpfr_t x;
4923     int t;
4924     mpfr_init (n);
4925     mpfr_init (x);
4926     mpfr_atan2 (n, n, x, GMP_RNDN);
4927     mpfr_erfc (n, x, GMP_RNDN);
4928     mpfr_subnormalize (x, t, GMP_RNDN);
4929
4930   ;
4931   return 0;
4932 }
4933 _ACEOF
4934 rm -f conftest.$ac_objext conftest$ac_exeext
4935 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4936   (eval $ac_link) 2>conftest.er1
4937   ac_status=$?
4938   grep -v '^ *+' conftest.er1 >conftest.err
4939   rm -f conftest.er1
4940   cat conftest.err >&5
4941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4942   (exit $ac_status); } &&
4943          { ac_try='test -z "$ac_c_werror_flag"
4944                          || test ! -s conftest.err'
4945   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4946   (eval $ac_try) 2>&5
4947   ac_status=$?
4948   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4949   (exit $ac_status); }; } &&
4950          { ac_try='test -s conftest$ac_exeext'
4951   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4952   (eval $ac_try) 2>&5
4953   ac_status=$?
4954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4955   (exit $ac_status); }; }; then
4956   echo "$as_me:$LINENO: result: yes" >&5
4957 echo "${ECHO_T}yes" >&6
4958 else
4959   echo "$as_me: failed program was:" >&5
4960 sed 's/^/| /' conftest.$ac_ext >&5
4961
4962 echo "$as_me:$LINENO: result: no" >&5
4963 echo "${ECHO_T}no" >&6; have_gmp=no
4964 fi
4965 rm -f conftest.err conftest.$ac_objext \
4966       conftest$ac_exeext conftest.$ac_ext
4967     LIBS="$saved_LIBS"
4968   fi
4969
4970   if test x"$have_mpc" = xmaybe; then
4971     saved_LIBS="$LIBS"
4972     LIBS="$LIBS $mpclibs $gmplibs"
4973     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4974 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4975     cat >conftest.$ac_ext <<_ACEOF
4976 /* confdefs.h.  */
4977 _ACEOF
4978 cat confdefs.h >>conftest.$ac_ext
4979 cat >>conftest.$ac_ext <<_ACEOF
4980 /* end confdefs.h.  */
4981 #include <mpc.h>
4982 int
4983 main ()
4984 {
4985
4986     mpc_t n;
4987     mpc_init2 (n, 53);
4988     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
4989     mpc_sin (n, n, MPC_RNDNN);
4990     mpc_cos (n, n, MPC_RNDNN);
4991     mpc_tan (n, n, MPC_RNDNN);
4992     mpc_sinh (n, n, MPC_RNDNN);
4993     mpc_cosh (n, n, MPC_RNDNN);
4994     mpc_tanh (n, n, MPC_RNDNN);
4995     mpc_exp (n, n, MPC_RNDNN);
4996     mpc_log (n, n, MPC_RNDNN);
4997     mpc_sqrt (n, n, MPC_RNDNN);
4998     mpc_proj (n, n, MPC_RNDNN);
4999     mpc_neg (n, n, MPC_RNDNN);
5000     mpc_sqr (n, n, MPC_RNDNN);
5001     mpc_clear (n);
5002
5003   ;
5004   return 0;
5005 }
5006 _ACEOF
5007 rm -f conftest.$ac_objext conftest$ac_exeext
5008 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5009   (eval $ac_link) 2>conftest.er1
5010   ac_status=$?
5011   grep -v '^ *+' conftest.er1 >conftest.err
5012   rm -f conftest.er1
5013   cat conftest.err >&5
5014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5015   (exit $ac_status); } &&
5016          { ac_try='test -z "$ac_c_werror_flag"
5017                          || test ! -s conftest.err'
5018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5019   (eval $ac_try) 2>&5
5020   ac_status=$?
5021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022   (exit $ac_status); }; } &&
5023          { ac_try='test -s conftest$ac_exeext'
5024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5025   (eval $ac_try) 2>&5
5026   ac_status=$?
5027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5028   (exit $ac_status); }; }; then
5029   echo "$as_me:$LINENO: result: yes" >&5
5030 echo "${ECHO_T}yes" >&6; have_mpc=yes
5031 else
5032   echo "$as_me: failed program was:" >&5
5033 sed 's/^/| /' conftest.$ac_ext >&5
5034
5035 echo "$as_me:$LINENO: result: no" >&5
5036 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5037 fi
5038 rm -f conftest.err conftest.$ac_objext \
5039       conftest$ac_exeext conftest.$ac_ext
5040     LIBS="$saved_LIBS"
5041   fi
5042
5043   CFLAGS="$saved_CFLAGS"
5044
5045   if test x$have_gmp != xyes; then
5046     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5047 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5048 Copies of these libraries' source code can be found at their respective
5049 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5050 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5051 If you obtained GMP and/or MPFR from a vendor distribution package, make
5052 sure that you have installed both the libraries and the header files.
5053 They may be located in separate packages." >&5
5054 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5055 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5056 Copies of these libraries' source code can be found at their respective
5057 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5058 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5059 If you obtained GMP and/or MPFR from a vendor distribution package, make
5060 sure that you have installed both the libraries and the header files.
5061 They may be located in separate packages." >&2;}
5062    { (exit 1); exit 1; }; }
5063   fi
5064 fi
5065
5066 if test x$have_mpc != xyes ; then
5067   mpcinc=
5068   mpclibs=
5069 fi
5070
5071 gmpinc="$mpcinc $gmpinc"
5072 gmplibs="$mpclibs $gmplibs"
5073
5074 # Flags needed for both GMP, MPFR and/or MPC.
5075
5076
5077
5078
5079
5080
5081 # Allow host libstdc++ to be specified for static linking with PPL.
5082
5083 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5084 if test "${with_host_libstdcxx+set}" = set; then
5085   withval="$with_host_libstdcxx"
5086
5087 fi;
5088
5089 case $with_host_libstdcxx in
5090   no|yes)
5091     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5092 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5093    { (exit 1); exit 1; }; }
5094     ;;
5095 esac
5096
5097 # Linker flags to use for stage1 or when not boostrapping.
5098
5099 # Check whether --with-stage1-ldflags or --without-stage1-ldflags was given.
5100 if test "${with_stage1_ldflags+set}" = set; then
5101   withval="$with_stage1_ldflags"
5102   if test "$withval" = "no" -o "$withval" = "yes"; then
5103    stage1_ldflags=
5104  else
5105    stage1_ldflags=$withval
5106  fi
5107 else
5108   stage1_ldflags=
5109 fi;
5110
5111
5112 # Libraries to use for stage1 or when not bootstrapping.
5113
5114 # Check whether --with-stage1-libs or --without-stage1-libs was given.
5115 if test "${with_stage1_libs+set}" = set; then
5116   withval="$with_stage1_libs"
5117   if test "$withval" = "no" -o "$withval" = "yes"; then
5118    stage1_libs=
5119  else
5120    stage1_libs=$withval
5121  fi
5122 else
5123   stage1_libs=$with_host_libstdcxx
5124 fi;
5125
5126
5127 # Linker flags to use for stage2 and later builds.
5128
5129 # Check whether --with-boot-ldflags or --without-boot-ldflags was given.
5130 if test "${with_boot_ldflags+set}" = set; then
5131   withval="$with_boot_ldflags"
5132   if test "$withval" = "no" -o "$withval" = "yes"; then
5133    poststage1_ldflags=
5134  else
5135    poststage1_ldflags=$withval
5136  fi
5137 else
5138   if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5139    poststage1_ldflags=-static-libstdc++
5140  else
5141    poststage1_ldflags=
5142  fi
5143 fi;
5144
5145
5146 # Libraries to use for stage2 and later builds.  This defaults to the
5147 # argument passed to --with-host-libstdcxx.
5148
5149 # Check whether --with-boot-libs or --without-boot-libs was given.
5150 if test "${with_boot_libs+set}" = set; then
5151   withval="$with_boot_libs"
5152   if test "$withval" = "no" -o "$withval" = "yes"; then
5153    poststage1_libs=
5154  else
5155    poststage1_libs=$withval
5156  fi
5157 else
5158   poststage1_libs=$with_host_libstdcxx
5159 fi;
5160
5161
5162 # Check for PPL
5163 ppl_major_version=0
5164 ppl_minor_version=10
5165 ppllibs=" -lppl_c -lppl -lgmpxx"
5166 pplinc=
5167
5168
5169 # Check whether --with-ppl or --without-ppl was given.
5170 if test "${with_ppl+set}" = set; then
5171   withval="$with_ppl"
5172
5173 else
5174   with_ppl=no
5175 fi;
5176
5177 # Check whether --with-ppl_include or --without-ppl_include was given.
5178 if test "${with_ppl_include+set}" = set; then
5179   withval="$with_ppl_include"
5180
5181 fi;
5182
5183 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5184 if test "${with_ppl_lib+set}" = set; then
5185   withval="$with_ppl_lib"
5186
5187 fi;
5188
5189 case $with_ppl in
5190   no)
5191     ppllibs=
5192     ;;
5193   *)
5194     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
5195     pplinc="-I$with_ppl/include $pplinc"
5196     LIBS="$ppllibs $LIBS"
5197     ;;
5198 esac
5199 if test "x$with_ppl_include" != x; then
5200   pplinc="-I$with_ppl_include $pplinc"
5201 fi
5202 if test "x$with_ppl_lib" != x; then
5203   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
5204   LIBS="$ppllibs $LIBS"
5205 fi
5206 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5207   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
5208   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5209   LIBS="$ppllibs $LIBS"
5210 fi
5211
5212 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5213 if test "${enable_ppl_version_check+set}" = set; then
5214   enableval="$enable_ppl_version_check"
5215   ENABLE_PPL_CHECK=$enableval
5216 else
5217   ENABLE_PPL_CHECK=yes
5218 fi;
5219
5220 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5221   saved_CFLAGS="$CFLAGS"
5222   CFLAGS="$CFLAGS $pplinc $gmpinc"
5223   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5224 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5225   cat >conftest.$ac_ext <<_ACEOF
5226 /* confdefs.h.  */
5227 _ACEOF
5228 cat confdefs.h >>conftest.$ac_ext
5229 cat >>conftest.$ac_ext <<_ACEOF
5230 /* end confdefs.h.  */
5231 #include "ppl_c.h"
5232 int
5233 main ()
5234 {
5235
5236   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5237   choke me
5238   #endif
5239
5240   ;
5241   return 0;
5242 }
5243 _ACEOF
5244 rm -f conftest.$ac_objext
5245 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5246   (eval $ac_compile) 2>conftest.er1
5247   ac_status=$?
5248   grep -v '^ *+' conftest.er1 >conftest.err
5249   rm -f conftest.er1
5250   cat conftest.err >&5
5251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5252   (exit $ac_status); } &&
5253          { ac_try='test -z "$ac_c_werror_flag"
5254                          || test ! -s conftest.err'
5255   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5256   (eval $ac_try) 2>&5
5257   ac_status=$?
5258   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5259   (exit $ac_status); }; } &&
5260          { ac_try='test -s conftest.$ac_objext'
5261   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5262   (eval $ac_try) 2>&5
5263   ac_status=$?
5264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5265   (exit $ac_status); }; }; then
5266   echo "$as_me:$LINENO: result: yes" >&5
5267 echo "${ECHO_T}yes" >&6
5268 else
5269   echo "$as_me: failed program was:" >&5
5270 sed 's/^/| /' conftest.$ac_ext >&5
5271
5272 echo "$as_me:$LINENO: result: no" >&5
5273 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5274 fi
5275 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5276   CFLAGS="$saved_CFLAGS"
5277 fi
5278
5279 # Flags needed for PPL
5280
5281
5282
5283
5284 # Check for CLOOG
5285 clooglibs=" -lcloog "
5286 clooginc=" -DCLOOG_PPL_BACKEND "
5287
5288
5289 # Check whether --with-cloog or --without-cloog was given.
5290 if test "${with_cloog+set}" = set; then
5291   withval="$with_cloog"
5292
5293 else
5294   with_cloog=no
5295 fi;
5296
5297 # Check whether --with-cloog_include or --without-cloog_include was given.
5298 if test "${with_cloog_include+set}" = set; then
5299   withval="$with_cloog_include"
5300
5301 fi;
5302
5303 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5304 if test "${with_cloog_lib+set}" = set; then
5305   withval="$with_cloog_lib"
5306
5307 fi;
5308
5309 case $with_cloog in
5310   no)
5311     clooglibs=
5312     clooginc=
5313     ;;
5314   *)
5315     clooglibs="-L$with_cloog/lib -lcloog"
5316     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5317     LIBS="$clooglibs $LIBS"
5318     ;;
5319 esac
5320 if test "x$with_cloog_include" != x; then
5321   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5322 fi
5323 if test "x$with_cloog_lib" != x; then
5324   clooglibs="-L$with_cloog_lib -lcloog"
5325   LIBS="$clooglibs $LIBS"
5326 fi
5327 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5328   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5329   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5330   LIBS="$clooglibs $LIBS"
5331 fi
5332
5333 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5334 if test "${enable_cloog_version_check+set}" = set; then
5335   enableval="$enable_cloog_version_check"
5336   ENABLE_CLOOG_CHECK=$enableval
5337 else
5338   ENABLE_CLOOG_CHECK=yes
5339 fi;
5340
5341 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5342   saved_CFLAGS="$CFLAGS"
5343   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5344   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5345 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5346   cat >conftest.$ac_ext <<_ACEOF
5347 /* confdefs.h.  */
5348 _ACEOF
5349 cat confdefs.h >>conftest.$ac_ext
5350 cat >>conftest.$ac_ext <<_ACEOF
5351 /* end confdefs.h.  */
5352 #include "cloog/cloog.h"
5353 int
5354 main ()
5355 {
5356
5357   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5358   choke me
5359   #endif
5360
5361   ;
5362   return 0;
5363 }
5364 _ACEOF
5365 rm -f conftest.$ac_objext
5366 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5367   (eval $ac_compile) 2>conftest.er1
5368   ac_status=$?
5369   grep -v '^ *+' conftest.er1 >conftest.err
5370   rm -f conftest.er1
5371   cat conftest.err >&5
5372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5373   (exit $ac_status); } &&
5374          { ac_try='test -z "$ac_c_werror_flag"
5375                          || test ! -s conftest.err'
5376   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5377   (eval $ac_try) 2>&5
5378   ac_status=$?
5379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5380   (exit $ac_status); }; } &&
5381          { ac_try='test -s conftest.$ac_objext'
5382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5383   (eval $ac_try) 2>&5
5384   ac_status=$?
5385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5386   (exit $ac_status); }; }; then
5387   echo "$as_me:$LINENO: result: yes" >&5
5388 echo "${ECHO_T}yes" >&6
5389 else
5390   echo "$as_me: failed program was:" >&5
5391 sed 's/^/| /' conftest.$ac_ext >&5
5392
5393 echo "$as_me:$LINENO: result: no" >&5
5394 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5395 fi
5396 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5397   CFLAGS="$saved_CFLAGS"
5398 fi
5399
5400 # Flags needed for CLOOG
5401
5402
5403
5404
5405 # By default, C is the only stage 1 language.
5406 stage1_languages=,c,
5407
5408 # Target libraries that we bootstrap.
5409 bootstrap_target_libs=,target-libgcc,
5410
5411 # Figure out what language subdirectories are present.
5412 # Look if the user specified --enable-languages="..."; if not, use
5413 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5414 # go away some day.
5415 # NB:  embedded tabs in this IF block -- do not untabify
5416 if test -d ${srcdir}/gcc; then
5417   if test x"${enable_languages+set}" != xset; then
5418     if test x"${LANGUAGES+set}" = xset; then
5419       enable_languages="${LANGUAGES}"
5420         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5421     else
5422       enable_languages=all
5423     fi
5424   else
5425     if test x"${enable_languages}" = x ||
5426        test x"${enable_languages}" = xyes;
5427        then
5428       echo configure.in: --enable-languages needs at least one language argument 1>&2
5429       exit 1
5430     fi
5431   fi
5432   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5433
5434   # 'f95' is the old name for the 'fortran' language. We issue a warning
5435   # and make the substitution.
5436   case ,${enable_languages}, in
5437     *,f95,*)
5438       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5439       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5440       ;;
5441   esac
5442
5443   # First scan to see if an enabled language requires some other language.
5444   # We assume that a given config-lang.in will list all the language
5445   # front ends it requires, even if some are required indirectly.
5446   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5447     case ${lang_frag} in
5448       ..) ;;
5449       # The odd quoting in the next line works around
5450       # an apparent bug in bash 1.12 on linux.
5451       ${srcdir}/gcc/[*]/config-lang.in) ;;
5452       *)
5453         # From the config-lang.in, get $language, $lang_requires
5454         language=
5455         lang_requires=
5456         . ${lang_frag}
5457         for other in ${lang_requires} ; do
5458           case ,${enable_languages}, in
5459             *,$other,*) ;;
5460             *,all,*) ;;
5461             *,$language,*)
5462               echo " \`$other' language required by \`$language'; enabling" 1>&2
5463               enable_languages="${enable_languages},${other}"
5464               ;;
5465           esac
5466         done
5467         ;;
5468     esac
5469   done
5470
5471   new_enable_languages=,c,
5472   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5473   potential_languages=,c,
5474
5475   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5476     case ${lang_frag} in
5477       ..) ;;
5478       # The odd quoting in the next line works around
5479       # an apparent bug in bash 1.12 on linux.
5480       ${srcdir}/gcc/[*]/config-lang.in) ;;
5481       *)
5482         # From the config-lang.in, get $language, $target_libs,
5483         # $lang_dirs, $boot_language, and $build_by_default
5484         language=
5485         target_libs=
5486         lang_dirs=
5487         subdir_requires=
5488         boot_language=no
5489         build_by_default=yes
5490         . ${lang_frag}
5491         if test x${language} = x; then
5492           echo "${lang_frag} doesn't set \$language." 1>&2
5493           exit 1
5494         fi
5495
5496         if test "$language" = "c++" -a "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5497           boot_language=yes
5498         fi
5499
5500         case ,${enable_languages}, in
5501           *,${language},*)
5502             # Language was explicitly selected; include it.
5503             add_this_lang=yes
5504             ;;
5505           *,all,*)
5506             # 'all' was selected, select it if it is a default language
5507             add_this_lang=${build_by_default}
5508             ;;
5509           *)
5510             add_this_lang=no
5511             ;;
5512         esac
5513
5514         # Disable languages that need other directories if these aren't available.
5515         for i in $subdir_requires; do
5516           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5517           case ,${enable_languages}, in
5518             *,${language},*)
5519               # Specifically requested language; tell them.
5520               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5521 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5522    { (exit 1); exit 1; }; }
5523               ;;
5524             *)
5525               # Silently disable.
5526               add_this_lang=unsupported
5527               ;;
5528           esac
5529         done
5530
5531         # Disable Ada if no preexisting GNAT is available.
5532         case ,${enable_languages},:${language}:${have_gnat} in
5533           *,${language},*:ada:no)
5534             # Specifically requested language; tell them.
5535             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5536 echo "$as_me: error: GNAT is required to build $language" >&2;}
5537    { (exit 1); exit 1; }; }
5538             ;;
5539           *:ada:no)
5540             # Silently disable.
5541             add_this_lang=unsupported
5542             ;;
5543         esac
5544
5545         # Disable a language that is unsupported by the target.
5546         case " $unsupported_languages " in
5547           *" $language "*)
5548             add_this_lang=unsupported
5549             ;;
5550         esac
5551
5552         case $add_this_lang in
5553           unsupported)
5554             # Remove language-dependent dirs.
5555             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5556             ;;
5557           no)
5558             # Remove language-dependent dirs; still show language as supported.
5559             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5560             potential_languages="${potential_languages}${language},"
5561             ;;
5562           yes)
5563             new_enable_languages="${new_enable_languages}${language},"
5564             potential_languages="${potential_languages}${language},"
5565             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5566             case ${boot_language} in
5567               yes)
5568                 # Add to (comma-separated) list of stage 1 languages.
5569                 stage1_languages="${stage1_languages}${language},"
5570                 # We need to bootstrap any supporting libraries.
5571                 bootstrap_target_libs="${bootstrap_target_libs}${target_libs},"
5572                 ;;
5573             esac
5574             ;;
5575         esac
5576         ;;
5577     esac
5578   done
5579
5580   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5581 if test "${enable_stage1_languages+set}" = set; then
5582   enableval="$enable_stage1_languages"
5583   case ,${enable_stage1_languages}, in
5584     ,no,|,,)
5585       # Set it to something that will have no effect in the loop below
5586       enable_stage1_languages=c ;;
5587     ,yes,)
5588       enable_stage1_languages=`echo $new_enable_languages | \
5589         sed -e "s/^,//" -e "s/,$//" ` ;;
5590     *,all,*)
5591       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5592         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5593   esac
5594
5595   # Add "good" languages from enable_stage1_languages to stage1_languages,
5596   # while "bad" languages go in missing_languages.  Leave no duplicates.
5597   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5598     case $potential_languages in
5599       *,$i,*)
5600         case $stage1_languages in
5601           *,$i,*) ;;
5602           *) stage1_languages="$stage1_languages$i," ;;
5603         esac ;;
5604       *)
5605         case $missing_languages in
5606           *,$i,*) ;;
5607           *) missing_languages="$missing_languages$i," ;;
5608         esac ;;
5609      esac
5610   done
5611 fi;
5612
5613   # Remove leading/trailing commas that were added for simplicity
5614   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5615   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5616   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5617   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5618
5619   if test "x$missing_languages" != x; then
5620     { { echo "$as_me:$LINENO: error:
5621 The following requested languages could not be built: ${missing_languages}
5622 Supported languages are: ${potential_languages}" >&5
5623 echo "$as_me: error:
5624 The following requested languages could not be built: ${missing_languages}
5625 Supported languages are: ${potential_languages}" >&2;}
5626    { (exit 1); exit 1; }; }
5627   fi
5628   if test "x$new_enable_languages" != "x$enable_languages"; then
5629     echo The following languages will be built: ${new_enable_languages}
5630     enable_languages="$new_enable_languages"
5631   fi
5632
5633
5634   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5635 fi
5636
5637 # Handle --disable-<component> generically.
5638 for dir in $configdirs $build_configdirs $target_configdirs ; do
5639   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5640   varname=`echo $dirname | sed -e s/+/_/g`
5641   if eval test x\${enable_${varname}} "=" xno ; then
5642     noconfigdirs="$noconfigdirs $dir"
5643   fi
5644 done
5645
5646 # Check for Boehm's garbage collector
5647 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5648 if test "${enable_objc_gc+set}" = set; then
5649   enableval="$enable_objc_gc"
5650   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5651   *,objc,*:*:yes:*target-boehm-gc*)
5652     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5653 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5654    { (exit 1); exit 1; }; }
5655     ;;
5656 esac
5657 fi;
5658
5659 # Make sure we only build Boehm's garbage collector if required.
5660 case ,${enable_languages},:${enable_objc_gc} in
5661   *,objc,*:yes)
5662     # Keep target-boehm-gc if requested for Objective-C.
5663     ;;
5664   *)
5665     # Otherwise remove target-boehm-gc depending on target-libjava.
5666     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5667       noconfigdirs="$noconfigdirs target-boehm-gc"
5668     fi
5669     ;;
5670 esac
5671
5672 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5673 # $build_configdirs and $target_configdirs.
5674 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5675
5676 notsupp=""
5677 for dir in . $skipdirs $noconfigdirs ; do
5678   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5679   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5680     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5681     if test -r $srcdir/$dirname/configure ; then
5682       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5683         true
5684       else
5685         notsupp="$notsupp $dir"
5686       fi
5687     fi
5688   fi
5689   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5690     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5691     if test -r $srcdir/$dirname/configure ; then
5692       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5693         true
5694       else
5695         notsupp="$notsupp $dir"
5696       fi
5697     fi
5698   fi
5699   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5700     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5701     if test -r $srcdir/$dirname/configure ; then
5702       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5703         true
5704       else
5705         notsupp="$notsupp $dir"
5706       fi
5707     fi
5708   fi
5709 done
5710
5711 # Sometimes the tools are distributed with libiberty but with no other
5712 # libraries.  In that case, we don't want to build target-libiberty.
5713 # Don't let libgcc imply libiberty either.
5714 if test -n "${target_configdirs}" ; then
5715   libgcc=
5716   others=
5717   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5718     if test "$i" = "libgcc"; then
5719       libgcc=target-libgcc
5720     elif test "$i" != "libiberty" ; then
5721       if test -r $srcdir/$i/configure ; then
5722         others=yes;
5723         break;
5724       fi
5725     fi
5726   done
5727   if test -z "${others}" ; then
5728     target_configdirs=$libgcc
5729   fi
5730 fi
5731
5732 # Quietly strip out all directories which aren't configurable in this tree.
5733 # This relies on all configurable subdirectories being autoconfiscated, which
5734 # is now the case.
5735 build_configdirs_all="$build_configdirs"
5736 build_configdirs=
5737 for i in ${build_configdirs_all} ; do
5738   j=`echo $i | sed -e s/build-//g`
5739   if test -f ${srcdir}/$j/configure ; then
5740     build_configdirs="${build_configdirs} $i"
5741   fi
5742 done
5743
5744 configdirs_all="$configdirs"
5745 configdirs=
5746 for i in ${configdirs_all} ; do
5747   if test -f ${srcdir}/$i/configure ; then
5748     configdirs="${configdirs} $i"
5749   fi
5750 done
5751
5752 target_configdirs_all="$target_configdirs"
5753 target_configdirs=
5754 for i in ${target_configdirs_all} ; do
5755   j=`echo $i | sed -e s/target-//g`
5756   if test -f ${srcdir}/$j/configure ; then
5757     target_configdirs="${target_configdirs} $i"
5758   fi
5759 done
5760
5761 # Produce a warning message for the subdirs we can't configure.
5762 # This isn't especially interesting in the Cygnus tree, but in the individual
5763 # FSF releases, it's important to let people know when their machine isn't
5764 # supported by the one or two programs in a package.
5765
5766 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5767   # If $appdirs is non-empty, at least one of those directories must still
5768   # be configured, or we error out.  (E.g., if the gas release supports a
5769   # specified target in some subdirs but not the gas subdir, we shouldn't
5770   # pretend that all is well.)
5771   if test -n "$appdirs" ; then
5772     for dir in $appdirs ; do
5773       if test -r $dir/Makefile.in ; then
5774         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5775           appdirs=""
5776           break
5777         fi
5778         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5779           appdirs=""
5780           break
5781         fi
5782       fi
5783     done
5784     if test -n "$appdirs" ; then
5785       echo "*** This configuration is not supported by this package." 1>&2
5786       exit 1
5787     fi
5788   fi
5789   # Okay, some application will build, or we don't care to check.  Still
5790   # notify of subdirs not getting built.
5791   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5792   echo "    ${notsupp}" 1>&2
5793   echo "    (Any other directories should still work fine.)" 1>&2
5794 fi
5795
5796 case "$host" in
5797   *msdosdjgpp*)
5798     enable_gdbtk=no ;;
5799 esac
5800
5801 # To find our prefix, in gcc_cv_tool_prefix.
5802
5803 # The user is always right.
5804 if test "${PATH_SEPARATOR+set}" != set; then
5805   echo "#! /bin/sh" >conf$$.sh
5806   echo  "exit 0"   >>conf$$.sh
5807   chmod +x conf$$.sh
5808   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5809     PATH_SEPARATOR=';'
5810   else
5811     PATH_SEPARATOR=:
5812   fi
5813   rm -f conf$$.sh
5814 fi
5815
5816
5817
5818 if test "x$exec_prefix" = xNONE; then
5819         if test "x$prefix" = xNONE; then
5820                 gcc_cv_tool_prefix=$ac_default_prefix
5821         else
5822                 gcc_cv_tool_prefix=$prefix
5823         fi
5824 else
5825         gcc_cv_tool_prefix=$exec_prefix
5826 fi
5827
5828 # If there is no compiler in the tree, use the PATH only.  In any
5829 # case, if there is no compiler in the tree nobody should use
5830 # AS_FOR_TARGET and LD_FOR_TARGET.
5831 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5832     gcc_version=`cat $srcdir/gcc/BASE-VER`
5833     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5834     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5835     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5836     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5837     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5838     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5839 else
5840     gcc_cv_tool_dirs=
5841 fi
5842
5843 if test x$build = x$target && test -n "$md_exec_prefix"; then
5844         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5845 fi
5846
5847
5848
5849 copy_dirs=
5850
5851
5852 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5853 if test "${with_build_sysroot+set}" = set; then
5854   withval="$with_build_sysroot"
5855   if test x"$withval" != x ; then
5856      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5857    fi
5858 else
5859   SYSROOT_CFLAGS_FOR_TARGET=
5860 fi;
5861
5862
5863
5864 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5865 if test "${with_debug_prefix_map+set}" = set; then
5866   withval="$with_debug_prefix_map"
5867   if test x"$withval" != x; then
5868      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5869      for debug_map in $withval; do
5870        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5871      done
5872    fi
5873 else
5874   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5875 fi;
5876
5877
5878 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5879 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5880 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5881 # We want to ensure that TARGET libraries (which we know are built with
5882 # gcc) are built with "-O2 -g", so include those options when setting
5883 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5884 if test "x$CFLAGS_FOR_TARGET" = x; then
5885   CFLAGS_FOR_TARGET=$CFLAGS
5886   case " $CFLAGS " in
5887     *" -O2 "*) ;;
5888     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5889   esac
5890   case " $CFLAGS " in
5891     *" -g "* | *" -g3 "*) ;;
5892     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5893   esac
5894 fi
5895
5896
5897 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5898   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5899   case " $CXXFLAGS " in
5900     *" -O2 "*) ;;
5901     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5902   esac
5903   case " $CXXFLAGS " in
5904     *" -g "* | *" -g3 "*) ;;
5905     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5906   esac
5907 fi
5908
5909
5910 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5911 # the named directory are copied to $(tooldir)/sys-include.
5912 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5913   if test x${is_cross_compiler} = xno ; then
5914     echo 1>&2 '***' --with-headers is only supported when cross compiling
5915     exit 1
5916   fi
5917   if test x"${with_headers}" != xyes ; then
5918     x=${gcc_cv_tool_prefix}
5919     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5920   fi
5921 fi
5922
5923 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5924 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5925 # are permitted.
5926 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5927   if test x${is_cross_compiler} = xno ; then
5928     echo 1>&2 '***' --with-libs is only supported when cross compiling
5929     exit 1
5930   fi
5931   if test x"${with_libs}" != xyes ; then
5932     # Copy the libraries in reverse order, so that files in the first named
5933     # library override files in subsequent libraries.
5934     x=${gcc_cv_tool_prefix}
5935     for l in ${with_libs}; do
5936       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5937     done
5938   fi
5939 fi
5940
5941 # Set with_gnu_as and with_gnu_ld as appropriate.
5942 #
5943 # This is done by determining whether or not the appropriate directory
5944 # is available, and by checking whether or not specific configurations
5945 # have requested that this magic not happen.
5946 #
5947 # The command line options always override the explicit settings in
5948 # configure.in, and the settings in configure.in override this magic.
5949 #
5950 # If the default for a toolchain is to use GNU as and ld, and you don't
5951 # want to do that, then you should use the --without-gnu-as and
5952 # --without-gnu-ld options for the configure script.
5953
5954 if test x${use_gnu_as} = x &&
5955    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5956   with_gnu_as=yes
5957   extra_host_args="$extra_host_args --with-gnu-as"
5958 fi
5959
5960 if test x${use_gnu_ld} = x &&
5961    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5962   with_gnu_ld=yes
5963   extra_host_args="$extra_host_args --with-gnu-ld"
5964 fi
5965
5966 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5967 # can detect this case.
5968
5969 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5970   with_newlib=yes
5971   extra_host_args="$extra_host_args --with-newlib"
5972 fi
5973
5974 # Handle ${copy_dirs}
5975 set fnord ${copy_dirs}
5976 shift
5977 while test $# != 0 ; do
5978   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5979     :
5980   else
5981     echo Copying $1 to $2
5982
5983     # Use the install script to create the directory and all required
5984     # parent directories.
5985     if test -d $2 ; then
5986       :
5987     else
5988       echo >config.temp
5989       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5990     fi
5991
5992     # Copy the directory, assuming we have tar.
5993     # FIXME: Should we use B in the second tar?  Not all systems support it.
5994     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5995
5996     # It is the responsibility of the user to correctly adjust all
5997     # symlinks.  If somebody can figure out how to handle them correctly
5998     # here, feel free to add the code.
5999
6000     echo $1 > $2/COPIED
6001   fi
6002   shift; shift
6003 done
6004
6005 # Determine a target-dependent exec_prefix that the installed
6006 # gcc will search in.  Keep this list sorted by triplet, with
6007 # the *-*-osname triplets last.
6008 md_exec_prefix=
6009 case "${target}" in
6010   alpha*-*-*vms*)
6011     md_exec_prefix=/gnu/lib/gcc-lib
6012     ;;
6013   i[34567]86-pc-msdosdjgpp*)
6014     md_exec_prefix=/dev/env/DJDIR/bin
6015     ;;
6016   i[34567]86-*-sco3.2v5*)
6017     if test $with_gnu_as = yes; then
6018       md_exec_prefix=/usr/gnu/bin
6019     else
6020       md_exec_prefix=/usr/ccs/bin/elf
6021     fi
6022     ;;
6023
6024   mn10300-*-* | \
6025   powerpc-*-chorusos* | \
6026   powerpc*-*-eabi* | \
6027   powerpc*-*-sysv* | \
6028   powerpc*-*-kaos* | \
6029   s390x-ibm-tpf*)
6030     md_exec_prefix=/usr/ccs/bin
6031     ;;
6032   sparc64-*-elf*)
6033     ;;
6034   v850*-*-*)
6035     md_exec_prefix=/usr/ccs/bin
6036     ;;
6037   xtensa*-*-elf*)
6038     ;;
6039
6040   *-*-beos* | \
6041   *-*-elf* | \
6042   *-*-hpux* | \
6043   *-*-netware* | \
6044   *-*-nto-qnx* | \
6045   *-*-rtems* | \
6046   *-*-solaris2* | \
6047   *-*-sysv[45]* | \
6048   *-*-vxworks* | \
6049   *-wrs-windiss)
6050     md_exec_prefix=/usr/ccs/bin
6051     ;;
6052 esac
6053
6054 extra_arflags_for_target=
6055 extra_nmflags_for_target=
6056 extra_ranlibflags_for_target=
6057 target_makefile_frag=/dev/null
6058 case "${target}" in
6059   mep*-*-*)
6060     target_makefile_frag="config/mt-mep"
6061     ;;
6062   spu-*-*)
6063     target_makefile_frag="config/mt-spu"
6064     ;;
6065   mips*-sde-elf*)
6066     target_makefile_frag="config/mt-sde"
6067     ;;
6068   mipsisa*-*-elfoabi*)
6069     target_makefile_frag="config/mt-mips-elfoabi"
6070     ;;
6071   mips*-*-*linux* | mips*-*-gnu*)
6072     target_makefile_frag="config/mt-mips-gnu"
6073     ;;
6074   *-*-netware*)
6075     target_makefile_frag="config/mt-netware"
6076     ;;
6077   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
6078     target_makefile_frag="config/mt-gnu"
6079     ;;
6080   *-*-aix4.[3456789]* | *-*-aix[56789].*)
6081     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
6082     # commands to handle both 32-bit and 64-bit objects.  These flags are
6083     # harmless if we're using GNU nm or ar.
6084     extra_arflags_for_target=" -X32_64"
6085     extra_nmflags_for_target=" -B -X32_64"
6086     ;;
6087   *-*-darwin*)
6088     # ranlib from Darwin requires the -c flag to look at common symbols.
6089     extra_ranlibflags_for_target=" -c"
6090     ;;
6091   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6092     target_makefile_frag="config/mt-wince"
6093     ;;
6094 esac
6095
6096 alphaieee_frag=/dev/null
6097 case $target in
6098   alpha*-*-*)
6099     # This just makes sure to use the -mieee option to build target libs.
6100     # This should probably be set individually by each library.
6101     alphaieee_frag="config/mt-alphaieee"
6102     ;;
6103 esac
6104
6105 # If --enable-target-optspace always use -Os instead of -O2 to build
6106 # the target libraries, similarly if it is not specified, use -Os
6107 # on selected platforms.
6108 ospace_frag=/dev/null
6109 case "${enable_target_optspace}:${target}" in
6110   yes:*)
6111     ospace_frag="config/mt-ospace"
6112     ;;
6113   :d30v-*)
6114     ospace_frag="config/mt-d30v"
6115     ;;
6116   :m32r-* | :d10v-* | :fr30-*)
6117     ospace_frag="config/mt-ospace"
6118     ;;
6119   no:* | :*)
6120     ;;
6121   *)
6122     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6123     ;;
6124 esac
6125
6126 # Default to using --with-stabs for certain targets.
6127 if test x${with_stabs} = x ; then
6128   case "${target}" in
6129   mips*-*-irix[56]*)
6130     ;;
6131   mips*-*-* | alpha*-*-osf*)
6132     with_stabs=yes;
6133     extra_host_args="${extra_host_args} --with-stabs"
6134     ;;
6135   esac
6136 fi
6137
6138 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6139 # them automatically.
6140 case "${host}" in
6141   hppa*64*-*-hpux11*)
6142     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6143     ;;
6144 esac
6145
6146 # Some systems (e.g., one of the i386-aix systems the gas testers are
6147 # using) don't handle "\$" correctly, so don't use it here.
6148 tooldir='${exec_prefix}'/${target_noncanonical}
6149 build_tooldir=${tooldir}
6150
6151 # Create a .gdbinit file which runs the one in srcdir
6152 # and tells GDB to look there for source files.
6153
6154 if test -r ${srcdir}/.gdbinit ; then
6155   case ${srcdir} in
6156     .) ;;
6157     *) cat > ./.gdbinit <<EOF
6158 # ${NO_EDIT}
6159 dir ${srcdir}
6160 dir .
6161 source ${srcdir}/.gdbinit
6162 EOF
6163     ;;
6164   esac
6165 fi
6166
6167 # Make sure that the compiler is able to generate an executable.  If it
6168 # can't, we are probably in trouble.  We don't care whether we can run the
6169 # executable--we might be using a cross compiler--we only care whether it
6170 # can be created.  At this point the main configure script has set CC.
6171 we_are_ok=no
6172 echo "int main () { return 0; }" > conftest.c
6173 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6174 if test $? = 0 ; then
6175   if test -s conftest || test -s conftest.exe ; then
6176     we_are_ok=yes
6177   fi
6178 fi
6179 case $we_are_ok in
6180   no)
6181     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6182     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6183     rm -f conftest*
6184     exit 1
6185     ;;
6186 esac
6187 rm -f conftest*
6188
6189 # The Solaris /usr/ucb/cc compiler does not appear to work.
6190 case "${host}" in
6191   sparc-sun-solaris2*)
6192       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6193       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6194           could_use=
6195           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6196           if test -d /opt/cygnus/bin ; then
6197               if test "$could_use" = "" ; then
6198                   could_use="/opt/cygnus/bin"
6199               else
6200                   could_use="$could_use or /opt/cygnus/bin"
6201               fi
6202           fi
6203         if test "$could_use" = "" ; then
6204             echo "Warning: compilation may fail because you're using"
6205             echo "/usr/ucb/cc.  You should change your PATH or CC "
6206             echo "variable and rerun configure."
6207         else
6208             echo "Warning: compilation may fail because you're using"
6209             echo "/usr/ucb/cc, when you should use the C compiler from"
6210             echo "$could_use.  You should change your"
6211             echo "PATH or CC variable and rerun configure."
6212         fi
6213       fi
6214   ;;
6215 esac
6216
6217 # Decide which environment variable is used to find dynamic libraries.
6218 case "${host}" in
6219   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6220   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6221   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6222   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6223 esac
6224
6225 # On systems where the dynamic library environment variable is PATH,
6226 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6227 # built executables to PATH.
6228 if test "$RPATH_ENVVAR" = PATH; then
6229   GCC_SHLIB_SUBDIR=/shlib
6230 else
6231   GCC_SHLIB_SUBDIR=
6232 fi
6233
6234 # Record target_configdirs and the configure arguments for target and
6235 # build configuration in Makefile.
6236 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6237 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6238
6239 # Determine whether gdb needs tk/tcl or not.
6240 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6241 # and in that case we want gdb to be built without tk.  Ugh!
6242 # In fact I believe gdb is the *only* package directly dependent on tk,
6243 # so we should be able to put the 'maybe's in unconditionally and
6244 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6245 # 100% sure that that's safe though.
6246
6247 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6248 case "$enable_gdbtk" in
6249   no)
6250     GDB_TK="" ;;
6251   yes)
6252     GDB_TK="${gdb_tk}" ;;
6253   *)
6254     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6255     # distro.  Eventually someone will fix this and move Insight, nee
6256     # gdbtk to a separate directory.
6257     if test -d ${srcdir}/gdb/gdbtk ; then
6258       GDB_TK="${gdb_tk}"
6259     else
6260       GDB_TK=""
6261     fi
6262     ;;
6263 esac
6264 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6265 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6266
6267 # Strip out unwanted targets.
6268
6269 # While at that, we remove Makefiles if we were started for recursive
6270 # configuration, so that the top-level Makefile reconfigures them,
6271 # like we used to do when configure itself was recursive.
6272
6273 # Loop over modules.  $extrasub must be used with care, limiting as
6274 # much as possible the usage of range addresses.  That's because autoconf
6275 # splits the sed script to overcome limits in the number of commands,
6276 # and relying on carefully-timed sed passes may turn out to be very hard
6277 # to maintain later.  In this particular case, you just have to be careful
6278 # not to nest @if/@endif pairs, because configure will not warn you at all.
6279
6280 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6281 if test "${enable_bootstrap+set}" = set; then
6282   enableval="$enable_bootstrap"
6283
6284 else
6285   enable_bootstrap=default
6286 fi;
6287
6288 # Issue errors and warnings for invalid/strange bootstrap combinations.
6289 case "$configdirs" in
6290   *gcc*) have_compiler=yes ;;
6291   *) have_compiler=no ;;
6292 esac
6293
6294 case "$have_compiler:$host:$target:$enable_bootstrap" in
6295   *:*:*:no) ;;
6296
6297   # Default behavior.  Enable bootstrap if we have a compiler
6298   # and we are in a native configuration.
6299   yes:$build:$build:default)
6300     enable_bootstrap=yes ;;
6301
6302   *:*:*:default)
6303     enable_bootstrap=no ;;
6304
6305   # We have a compiler and we are in a native configuration, bootstrap is ok
6306   yes:$build:$build:yes)
6307     ;;
6308
6309   # Other configurations, but we have a compiler.  Assume the user knows
6310   # what he's doing.
6311   yes:*:*:yes)
6312     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6313 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6314     ;;
6315
6316   # No compiler: if they passed --enable-bootstrap explicitly, fail
6317   no:*:*:yes)
6318     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6319 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6320    { (exit 1); exit 1; }; } ;;
6321
6322   # Fail if wrong command line
6323   *)
6324     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6325 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6326    { (exit 1); exit 1; }; }
6327     ;;
6328 esac
6329
6330 # Adjust the toplevel makefile according to whether bootstrap was selected.
6331 case "$enable_bootstrap" in
6332   yes)
6333     bootstrap_suffix=bootstrap ;;
6334   no)
6335     bootstrap_suffix=no-bootstrap ;;
6336 esac
6337
6338 for module in ${build_configdirs} ; do
6339   if test -z "${no_recursion}" \
6340      && test -f ${build_subdir}/${module}/Makefile; then
6341     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6342     rm -f ${build_subdir}/${module}/Makefile
6343   fi
6344   extrasub="$extrasub
6345 /^@if build-$module\$/d
6346 /^@endif build-$module\$/d
6347 /^@if build-$module-$bootstrap_suffix\$/d
6348 /^@endif build-$module-$bootstrap_suffix\$/d"
6349 done
6350 for module in ${configdirs} ; do
6351   if test -z "${no_recursion}"; then
6352     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6353       if test -f ${file}; then
6354         echo 1>&2 "*** removing ${file} to force reconfigure"
6355         rm -f ${file}
6356       fi
6357     done
6358   fi
6359   extrasub="$extrasub
6360 /^@if $module\$/d
6361 /^@endif $module\$/d
6362 /^@if $module-$bootstrap_suffix\$/d
6363 /^@endif $module-$bootstrap_suffix\$/d"
6364 done
6365 for module in ${target_configdirs} ; do
6366   if test -z "${no_recursion}" \
6367      && test -f ${target_subdir}/${module}/Makefile; then
6368     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6369     rm -f ${target_subdir}/${module}/Makefile
6370   fi
6371
6372   # We only bootstrap target libraries listed in bootstrap_target_libs.
6373   case $bootstrap_target_libs in
6374     *,target-$module,*) target_bootstrap_suffix=$bootstrap_suffix ;;
6375     *) target_bootstrap_suffix=no-bootstrap ;;
6376   esac
6377
6378   extrasub="$extrasub
6379 /^@if target-$module\$/d
6380 /^@endif target-$module\$/d
6381 /^@if target-$module-$target_bootstrap_suffix\$/d
6382 /^@endif target-$module-$target_bootstrap_suffix\$/d"
6383 done
6384
6385 extrasub="$extrasub
6386 /^@if /,/^@endif /d"
6387
6388 # Create the serialization dependencies.  This uses a temporary file.
6389
6390 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6391 if test "${enable_serial_configure+set}" = set; then
6392   enableval="$enable_serial_configure"
6393
6394 fi;
6395
6396 case ${enable_serial_configure} in
6397   yes)
6398     enable_serial_build_configure=yes
6399     enable_serial_host_configure=yes
6400     enable_serial_target_configure=yes
6401     ;;
6402 esac
6403
6404 # These force 'configure's to be done one at a time, to avoid problems
6405 # with contention over a shared config.cache.
6406 rm -f serdep.tmp
6407 echo '# serdep.tmp' > serdep.tmp
6408 olditem=
6409 test "x${enable_serial_build_configure}" = xyes &&
6410 for item in ${build_configdirs} ; do
6411   case ${olditem} in
6412     "") ;;
6413     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6414   esac
6415   olditem=${item}
6416 done
6417 olditem=
6418 test "x${enable_serial_host_configure}" = xyes &&
6419 for item in ${configdirs} ; do
6420   case ${olditem} in
6421     "") ;;
6422     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6423   esac
6424   olditem=${item}
6425 done
6426 olditem=
6427 test "x${enable_serial_target_configure}" = xyes &&
6428 for item in ${target_configdirs} ; do
6429   case ${olditem} in
6430     "") ;;
6431     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6432   esac
6433   olditem=${item}
6434 done
6435 serialization_dependencies=serdep.tmp
6436
6437
6438 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6439 # target, nonopt, and variable assignments.  These are the ones we
6440 # might not want to pass down to subconfigures.  Also strip
6441 # program-prefix, program-suffix, and program-transform-name, so that
6442 # we can pass down a consistent program-transform-name.
6443 baseargs=
6444 keep_next=no
6445 skip_next=no
6446 eval "set -- $ac_configure_args"
6447 for ac_arg
6448 do
6449   if test X"$skip_next" = X"yes"; then
6450     skip_next=no
6451     continue
6452   fi
6453   if test X"$keep_next" = X"yes"; then
6454     case $ac_arg in
6455       *\'*)
6456         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6457     esac
6458     baseargs="$baseargs '$ac_arg'"
6459     keep_next=no
6460     continue
6461   fi
6462
6463   # Handle separated arguments.  Based on the logic generated by
6464   # autoconf 2.59.
6465   case $ac_arg in
6466     *=* | --config-cache | -C | -disable-* | --disable-* \
6467       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6468       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6469       | -with-* | --with-* | -without-* | --without-* | --x)
6470       separate_arg=no
6471       ;;
6472     -*)
6473       separate_arg=yes
6474       ;;
6475     *)
6476       separate_arg=no
6477       ;;
6478   esac
6479
6480   case "$ac_arg" in
6481     --no*)
6482       continue
6483       ;;
6484     --c* | \
6485     --sr* | \
6486     --ho* | \
6487     --bu* | \
6488     --t* | \
6489     --program-* | \
6490     -cache_file* | \
6491     -srcdir* | \
6492     -host* | \
6493     -build* | \
6494     -target* | \
6495     -program-prefix* | \
6496     -program-suffix* | \
6497     -program-transform-name* )
6498       skip_next=$separate_arg
6499       continue
6500       ;;
6501     -*)
6502       # An option.  Add it.
6503       case $ac_arg in
6504         *\'*)
6505           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6506       esac
6507       baseargs="$baseargs '$ac_arg'"
6508       keep_next=$separate_arg
6509       ;;
6510     *)
6511       # Either a variable assignment, or a nonopt (triplet).  Don't
6512       # pass it down; let the Makefile handle this.
6513       continue
6514       ;;
6515   esac
6516 done
6517 # Remove the initial space we just introduced and, as these will be
6518 # expanded by make, quote '$'.
6519 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6520
6521 # Add in --program-transform-name, after --program-prefix and
6522 # --program-suffix have been applied to it.  Autoconf has already
6523 # doubled dollar signs and backslashes in program_transform_name; we want
6524 # the backslashes un-doubled, and then the entire thing wrapped in single
6525 # quotes, because this will be expanded first by make and then by the shell.
6526 # Also, because we want to override the logic in subdir configure scripts to
6527 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6528 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6529 ${program_transform_name}
6530 EOF_SED
6531 gcc_transform_name=`cat conftestsed.out`
6532 rm -f conftestsed.out
6533 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6534 if test "$silent" = yes; then
6535   baseargs="$baseargs --silent"
6536 fi
6537
6538 # For the build-side libraries, we just need to pretend we're native,
6539 # and not use the same cache file.  Multilibs are neither needed nor
6540 # desired.
6541 build_configargs="--cache-file=../config.cache ${baseargs}"
6542
6543 # For host modules, accept cache file option, or specification as blank.
6544 case "${cache_file}" in
6545 "") # empty
6546   cache_file_option="" ;;
6547 /* | [A-Za-z]:[\\/]* ) # absolute path
6548   cache_file_option="--cache-file=${cache_file}" ;;
6549 *) # relative path
6550   cache_file_option="--cache-file=../${cache_file}" ;;
6551 esac
6552
6553 # Host dirs don't like to share a cache file either, horribly enough.
6554 # This seems to be due to autoconf 2.5x stupidity.
6555 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6556
6557 target_configargs=${baseargs}
6558
6559 # Passing a --with-cross-host argument lets the target libraries know
6560 # whether they are being built with a cross-compiler or being built
6561 # native.  However, it would be better to use other mechanisms to make the
6562 # sorts of decisions they want to make on this basis.  Please consider
6563 # this option to be deprecated.  FIXME.
6564 if test x${is_cross_compiler} = xyes ; then
6565   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6566 fi
6567
6568 # Default to --enable-multilib.
6569 if test x${enable_multilib} = x ; then
6570   target_configargs="--enable-multilib ${target_configargs}"
6571 fi
6572
6573 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6574 # changed from the earlier setting of with_newlib.
6575 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6576   target_configargs="--with-newlib ${target_configargs}"
6577 fi
6578
6579 # Different target subdirs use different values of certain variables
6580 # (notably CXX).  Worse, multilibs use *lots* of different values.
6581 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6582 # it doesn't automatically accept command-line overrides of them.
6583 # This means it's not safe for target subdirs to share a cache file,
6584 # which is disgusting, but there you have it.  Hopefully this can be
6585 # fixed in future.  It's still worthwhile to use a cache file for each
6586 # directory.  I think.
6587
6588 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6589 # We need to pass --target, as newer autoconf's requires consistency
6590 # for target_alias and gcc doesn't manage it consistently.
6591 target_configargs="--cache-file=./config.cache ${target_configargs}"
6592
6593 FLAGS_FOR_TARGET=
6594 case " $target_configdirs " in
6595  *" newlib "*)
6596   case " $target_configargs " in
6597   *" --with-newlib "*)
6598    case "$target" in
6599    *-cygwin*)
6600      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' ;;
6601    esac
6602
6603    # If we're not building GCC, don't discard standard headers.
6604    if test -d ${srcdir}/gcc; then
6605      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6606
6607      if test "${build}" != "${host}"; then
6608        # On Canadian crosses, CC_FOR_TARGET will have already been set
6609        # by `configure', so we won't have an opportunity to add -Bgcc/
6610        # to it.  This is right: we don't want to search that directory
6611        # for binaries, but we want the header files in there, so add
6612        # them explicitly.
6613        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6614
6615        # Someone might think of using the pre-installed headers on
6616        # Canadian crosses, in case the installed compiler is not fully
6617        # compatible with the compiler being built.  In this case, it
6618        # would be better to flag an error than risking having
6619        # incompatible object files being constructed.  We can't
6620        # guarantee that an error will be flagged, but let's hope the
6621        # compiler will do it, when presented with incompatible header
6622        # files.
6623      fi
6624    fi
6625
6626    case "${target}-${is_cross_compiler}" in
6627    i[3456789]86-*-linux*-no)
6628       # Here host == target, so we don't need to build gcc,
6629       # so we don't want to discard standard headers.
6630       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6631       ;;
6632    *)
6633       # If we're building newlib, use its generic headers last, but search
6634       # for any libc-related directories first (so make it the last -B
6635       # switch).
6636       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6637
6638       # If we're building libgloss, find the startup file, simulator library
6639       # and linker script.
6640       case " $target_configdirs " in
6641         *" libgloss "*)
6642         # Look for startup file, simulator library and maybe linker script.
6643         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6644         # Look for libnosys.a in case the target needs it.
6645         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6646         # Most targets have the linker script in the source directory.
6647         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6648         ;;
6649       esac
6650       ;;
6651    esac
6652    ;;
6653   esac
6654   ;;
6655 esac
6656 case "$target" in
6657 *-mingw*)
6658   # Can't be handled as Cygwin above since Mingw does not use newlib.
6659   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' ;;
6660 esac
6661
6662 # Allow the user to override the flags for
6663 # our build compiler if desired.
6664 if test x"${build}" = x"${host}" ; then
6665   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6666   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6667   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6668 fi
6669
6670 # On Canadian crosses, we'll be searching the right directories for
6671 # the previously-installed cross compiler, so don't bother to add
6672 # flags for directories within the install tree of the compiler
6673 # being built; programs in there won't even run.
6674 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6675   # Search for pre-installed headers if nothing else fits.
6676   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6677 fi
6678
6679 if test "x${use_gnu_ld}" = x &&
6680    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6681   # Arrange for us to find uninstalled linker scripts.
6682   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6683 fi
6684
6685 # Search for other target-specific linker scripts and such.
6686 case "${target}" in
6687   mep*)
6688     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6689     ;;
6690 esac
6691
6692 # Makefile fragments.
6693 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6694 do
6695   eval fragval=\$$frag
6696   if test $fragval != /dev/null; then
6697     eval $frag=${srcdir}/$fragval
6698   fi
6699 done
6700
6701
6702
6703
6704
6705 # Miscellanea: directories, flags, etc.
6706
6707
6708
6709
6710
6711
6712
6713
6714 # Build module lists & subconfigure args.
6715
6716
6717
6718 # Host module lists & subconfigure args.
6719
6720
6721
6722 # Target module lists & subconfigure args.
6723
6724
6725
6726 # Build tools.
6727
6728
6729
6730
6731
6732
6733
6734
6735
6736
6737
6738
6739
6740
6741
6742
6743
6744 # Generate default definitions for YACC, M4, LEX and other programs that run
6745 # on the build machine.  These are used if the Makefile can't locate these
6746 # programs in objdir.
6747 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6748
6749 for ac_prog in 'bison -y' byacc yacc
6750 do
6751   # Extract the first word of "$ac_prog", so it can be a program name with args.
6752 set dummy $ac_prog; ac_word=$2
6753 echo "$as_me:$LINENO: checking for $ac_word" >&5
6754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6755 if test "${ac_cv_prog_YACC+set}" = set; then
6756   echo $ECHO_N "(cached) $ECHO_C" >&6
6757 else
6758   if test -n "$YACC"; then
6759   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6760 else
6761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6762 for as_dir in $PATH
6763 do
6764   IFS=$as_save_IFS
6765   test -z "$as_dir" && as_dir=.
6766   for ac_exec_ext in '' $ac_executable_extensions; do
6767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6768     ac_cv_prog_YACC="$ac_prog"
6769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6770     break 2
6771   fi
6772 done
6773 done
6774
6775 fi
6776 fi
6777 YACC=$ac_cv_prog_YACC
6778 if test -n "$YACC"; then
6779   echo "$as_me:$LINENO: result: $YACC" >&5
6780 echo "${ECHO_T}$YACC" >&6
6781 else
6782   echo "$as_me:$LINENO: result: no" >&5
6783 echo "${ECHO_T}no" >&6
6784 fi
6785
6786   test -n "$YACC" && break
6787 done
6788 test -n "$YACC" || YACC="$MISSING bison -y"
6789
6790 case " $build_configdirs " in
6791   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6792   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6793 esac
6794
6795 for ac_prog in bison
6796 do
6797   # Extract the first word of "$ac_prog", so it can be a program name with args.
6798 set dummy $ac_prog; ac_word=$2
6799 echo "$as_me:$LINENO: checking for $ac_word" >&5
6800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6801 if test "${ac_cv_prog_BISON+set}" = set; then
6802   echo $ECHO_N "(cached) $ECHO_C" >&6
6803 else
6804   if test -n "$BISON"; then
6805   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6806 else
6807 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6808 for as_dir in $PATH
6809 do
6810   IFS=$as_save_IFS
6811   test -z "$as_dir" && as_dir=.
6812   for ac_exec_ext in '' $ac_executable_extensions; do
6813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6814     ac_cv_prog_BISON="$ac_prog"
6815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6816     break 2
6817   fi
6818 done
6819 done
6820
6821 fi
6822 fi
6823 BISON=$ac_cv_prog_BISON
6824 if test -n "$BISON"; then
6825   echo "$as_me:$LINENO: result: $BISON" >&5
6826 echo "${ECHO_T}$BISON" >&6
6827 else
6828   echo "$as_me:$LINENO: result: no" >&5
6829 echo "${ECHO_T}no" >&6
6830 fi
6831
6832   test -n "$BISON" && break
6833 done
6834 test -n "$BISON" || BISON="$MISSING bison"
6835
6836 case " $build_configdirs " in
6837   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6838 esac
6839
6840 for ac_prog in gm4 gnum4 m4
6841 do
6842   # Extract the first word of "$ac_prog", so it can be a program name with args.
6843 set dummy $ac_prog; ac_word=$2
6844 echo "$as_me:$LINENO: checking for $ac_word" >&5
6845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6846 if test "${ac_cv_prog_M4+set}" = set; then
6847   echo $ECHO_N "(cached) $ECHO_C" >&6
6848 else
6849   if test -n "$M4"; then
6850   ac_cv_prog_M4="$M4" # Let the user override the test.
6851 else
6852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6853 for as_dir in $PATH
6854 do
6855   IFS=$as_save_IFS
6856   test -z "$as_dir" && as_dir=.
6857   for ac_exec_ext in '' $ac_executable_extensions; do
6858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6859     ac_cv_prog_M4="$ac_prog"
6860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6861     break 2
6862   fi
6863 done
6864 done
6865
6866 fi
6867 fi
6868 M4=$ac_cv_prog_M4
6869 if test -n "$M4"; then
6870   echo "$as_me:$LINENO: result: $M4" >&5
6871 echo "${ECHO_T}$M4" >&6
6872 else
6873   echo "$as_me:$LINENO: result: no" >&5
6874 echo "${ECHO_T}no" >&6
6875 fi
6876
6877   test -n "$M4" && break
6878 done
6879 test -n "$M4" || M4="$MISSING m4"
6880
6881 case " $build_configdirs " in
6882   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6883 esac
6884
6885 for ac_prog in flex lex
6886 do
6887   # Extract the first word of "$ac_prog", so it can be a program name with args.
6888 set dummy $ac_prog; ac_word=$2
6889 echo "$as_me:$LINENO: checking for $ac_word" >&5
6890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6891 if test "${ac_cv_prog_LEX+set}" = set; then
6892   echo $ECHO_N "(cached) $ECHO_C" >&6
6893 else
6894   if test -n "$LEX"; then
6895   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6896 else
6897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6898 for as_dir in $PATH
6899 do
6900   IFS=$as_save_IFS
6901   test -z "$as_dir" && as_dir=.
6902   for ac_exec_ext in '' $ac_executable_extensions; do
6903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6904     ac_cv_prog_LEX="$ac_prog"
6905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6906     break 2
6907   fi
6908 done
6909 done
6910
6911 fi
6912 fi
6913 LEX=$ac_cv_prog_LEX
6914 if test -n "$LEX"; then
6915   echo "$as_me:$LINENO: result: $LEX" >&5
6916 echo "${ECHO_T}$LEX" >&6
6917 else
6918   echo "$as_me:$LINENO: result: no" >&5
6919 echo "${ECHO_T}no" >&6
6920 fi
6921
6922   test -n "$LEX" && break
6923 done
6924 test -n "$LEX" || LEX="$MISSING flex"
6925
6926 case " $build_configdirs " in
6927   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6928   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6929 esac
6930
6931 for ac_prog in flex
6932 do
6933   # Extract the first word of "$ac_prog", so it can be a program name with args.
6934 set dummy $ac_prog; ac_word=$2
6935 echo "$as_me:$LINENO: checking for $ac_word" >&5
6936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6937 if test "${ac_cv_prog_FLEX+set}" = set; then
6938   echo $ECHO_N "(cached) $ECHO_C" >&6
6939 else
6940   if test -n "$FLEX"; then
6941   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6942 else
6943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6944 for as_dir in $PATH
6945 do
6946   IFS=$as_save_IFS
6947   test -z "$as_dir" && as_dir=.
6948   for ac_exec_ext in '' $ac_executable_extensions; do
6949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6950     ac_cv_prog_FLEX="$ac_prog"
6951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6952     break 2
6953   fi
6954 done
6955 done
6956
6957 fi
6958 fi
6959 FLEX=$ac_cv_prog_FLEX
6960 if test -n "$FLEX"; then
6961   echo "$as_me:$LINENO: result: $FLEX" >&5
6962 echo "${ECHO_T}$FLEX" >&6
6963 else
6964   echo "$as_me:$LINENO: result: no" >&5
6965 echo "${ECHO_T}no" >&6
6966 fi
6967
6968   test -n "$FLEX" && break
6969 done
6970 test -n "$FLEX" || FLEX="$MISSING flex"
6971
6972 case " $build_configdirs " in
6973   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6974 esac
6975
6976 for ac_prog in makeinfo
6977 do
6978   # Extract the first word of "$ac_prog", so it can be a program name with args.
6979 set dummy $ac_prog; ac_word=$2
6980 echo "$as_me:$LINENO: checking for $ac_word" >&5
6981 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6982 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6983   echo $ECHO_N "(cached) $ECHO_C" >&6
6984 else
6985   if test -n "$MAKEINFO"; then
6986   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6987 else
6988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6989 for as_dir in $PATH
6990 do
6991   IFS=$as_save_IFS
6992   test -z "$as_dir" && as_dir=.
6993   for ac_exec_ext in '' $ac_executable_extensions; do
6994   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6995     ac_cv_prog_MAKEINFO="$ac_prog"
6996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6997     break 2
6998   fi
6999 done
7000 done
7001
7002 fi
7003 fi
7004 MAKEINFO=$ac_cv_prog_MAKEINFO
7005 if test -n "$MAKEINFO"; then
7006   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
7007 echo "${ECHO_T}$MAKEINFO" >&6
7008 else
7009   echo "$as_me:$LINENO: result: no" >&5
7010 echo "${ECHO_T}no" >&6
7011 fi
7012
7013   test -n "$MAKEINFO" && break
7014 done
7015 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
7016
7017 case " $build_configdirs " in
7018   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
7019   *)
7020
7021     # For an installed makeinfo, we require it to be from texinfo 4.7 or
7022     # higher, else we use the "missing" dummy.
7023     if ${MAKEINFO} --version \
7024        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
7025       :
7026     else
7027       MAKEINFO="$MISSING makeinfo"
7028     fi
7029     ;;
7030
7031 esac
7032
7033 # FIXME: expect and dejagnu may become build tools?
7034
7035 for ac_prog in expect
7036 do
7037   # Extract the first word of "$ac_prog", so it can be a program name with args.
7038 set dummy $ac_prog; ac_word=$2
7039 echo "$as_me:$LINENO: checking for $ac_word" >&5
7040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7041 if test "${ac_cv_prog_EXPECT+set}" = set; then
7042   echo $ECHO_N "(cached) $ECHO_C" >&6
7043 else
7044   if test -n "$EXPECT"; then
7045   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
7046 else
7047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7048 for as_dir in $PATH
7049 do
7050   IFS=$as_save_IFS
7051   test -z "$as_dir" && as_dir=.
7052   for ac_exec_ext in '' $ac_executable_extensions; do
7053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7054     ac_cv_prog_EXPECT="$ac_prog"
7055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7056     break 2
7057   fi
7058 done
7059 done
7060
7061 fi
7062 fi
7063 EXPECT=$ac_cv_prog_EXPECT
7064 if test -n "$EXPECT"; then
7065   echo "$as_me:$LINENO: result: $EXPECT" >&5
7066 echo "${ECHO_T}$EXPECT" >&6
7067 else
7068   echo "$as_me:$LINENO: result: no" >&5
7069 echo "${ECHO_T}no" >&6
7070 fi
7071
7072   test -n "$EXPECT" && break
7073 done
7074 test -n "$EXPECT" || EXPECT="expect"
7075
7076 case " $configdirs " in
7077   *" expect "*)
7078     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
7079     ;;
7080 esac
7081
7082 for ac_prog in runtest
7083 do
7084   # Extract the first word of "$ac_prog", so it can be a program name with args.
7085 set dummy $ac_prog; ac_word=$2
7086 echo "$as_me:$LINENO: checking for $ac_word" >&5
7087 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7088 if test "${ac_cv_prog_RUNTEST+set}" = set; then
7089   echo $ECHO_N "(cached) $ECHO_C" >&6
7090 else
7091   if test -n "$RUNTEST"; then
7092   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
7093 else
7094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7095 for as_dir in $PATH
7096 do
7097   IFS=$as_save_IFS
7098   test -z "$as_dir" && as_dir=.
7099   for ac_exec_ext in '' $ac_executable_extensions; do
7100   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7101     ac_cv_prog_RUNTEST="$ac_prog"
7102     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7103     break 2
7104   fi
7105 done
7106 done
7107
7108 fi
7109 fi
7110 RUNTEST=$ac_cv_prog_RUNTEST
7111 if test -n "$RUNTEST"; then
7112   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7113 echo "${ECHO_T}$RUNTEST" >&6
7114 else
7115   echo "$as_me:$LINENO: result: no" >&5
7116 echo "${ECHO_T}no" >&6
7117 fi
7118
7119   test -n "$RUNTEST" && break
7120 done
7121 test -n "$RUNTEST" || RUNTEST="runtest"
7122
7123 case " $configdirs " in
7124   *" dejagnu "*)
7125     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7126     ;;
7127 esac
7128
7129
7130 # Host tools.
7131 ncn_tool_prefix=
7132 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7133 ncn_target_tool_prefix=
7134 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7135
7136
7137
7138 if test -n "$AR"; then
7139   ac_cv_prog_AR=$AR
7140 elif test -n "$ac_cv_prog_AR"; then
7141   AR=$ac_cv_prog_AR
7142 fi
7143
7144 if test -n "$ac_cv_prog_AR"; then
7145   for ncn_progname in ar; do
7146     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7147 set dummy ${ncn_progname}; ac_word=$2
7148 echo "$as_me:$LINENO: checking for $ac_word" >&5
7149 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7150 if test "${ac_cv_prog_AR+set}" = set; then
7151   echo $ECHO_N "(cached) $ECHO_C" >&6
7152 else
7153   if test -n "$AR"; then
7154   ac_cv_prog_AR="$AR" # Let the user override the test.
7155 else
7156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7157 for as_dir in $PATH
7158 do
7159   IFS=$as_save_IFS
7160   test -z "$as_dir" && as_dir=.
7161   for ac_exec_ext in '' $ac_executable_extensions; do
7162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7163     ac_cv_prog_AR="${ncn_progname}"
7164     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7165     break 2
7166   fi
7167 done
7168 done
7169
7170 fi
7171 fi
7172 AR=$ac_cv_prog_AR
7173 if test -n "$AR"; then
7174   echo "$as_me:$LINENO: result: $AR" >&5
7175 echo "${ECHO_T}$AR" >&6
7176 else
7177   echo "$as_me:$LINENO: result: no" >&5
7178 echo "${ECHO_T}no" >&6
7179 fi
7180
7181   done
7182 fi
7183
7184 for ncn_progname in ar; do
7185   if test -n "$ncn_tool_prefix"; then
7186     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7187 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7188 echo "$as_me:$LINENO: checking for $ac_word" >&5
7189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7190 if test "${ac_cv_prog_AR+set}" = set; then
7191   echo $ECHO_N "(cached) $ECHO_C" >&6
7192 else
7193   if test -n "$AR"; then
7194   ac_cv_prog_AR="$AR" # Let the user override the test.
7195 else
7196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7197 for as_dir in $PATH
7198 do
7199   IFS=$as_save_IFS
7200   test -z "$as_dir" && as_dir=.
7201   for ac_exec_ext in '' $ac_executable_extensions; do
7202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7203     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7205     break 2
7206   fi
7207 done
7208 done
7209
7210 fi
7211 fi
7212 AR=$ac_cv_prog_AR
7213 if test -n "$AR"; then
7214   echo "$as_me:$LINENO: result: $AR" >&5
7215 echo "${ECHO_T}$AR" >&6
7216 else
7217   echo "$as_me:$LINENO: result: no" >&5
7218 echo "${ECHO_T}no" >&6
7219 fi
7220
7221   fi
7222   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7223     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7224 set dummy ${ncn_progname}; ac_word=$2
7225 echo "$as_me:$LINENO: checking for $ac_word" >&5
7226 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7227 if test "${ac_cv_prog_AR+set}" = set; then
7228   echo $ECHO_N "(cached) $ECHO_C" >&6
7229 else
7230   if test -n "$AR"; then
7231   ac_cv_prog_AR="$AR" # Let the user override the test.
7232 else
7233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7234 for as_dir in $PATH
7235 do
7236   IFS=$as_save_IFS
7237   test -z "$as_dir" && as_dir=.
7238   for ac_exec_ext in '' $ac_executable_extensions; do
7239   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7240     ac_cv_prog_AR="${ncn_progname}"
7241     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7242     break 2
7243   fi
7244 done
7245 done
7246
7247 fi
7248 fi
7249 AR=$ac_cv_prog_AR
7250 if test -n "$AR"; then
7251   echo "$as_me:$LINENO: result: $AR" >&5
7252 echo "${ECHO_T}$AR" >&6
7253 else
7254   echo "$as_me:$LINENO: result: no" >&5
7255 echo "${ECHO_T}no" >&6
7256 fi
7257
7258   fi
7259   test -n "$ac_cv_prog_AR" && break
7260 done
7261
7262 if test -z "$ac_cv_prog_AR" ; then
7263   set dummy ar
7264   if test $build = $host ; then
7265     AR="$2"
7266   else
7267     AR="${ncn_tool_prefix}$2"
7268   fi
7269 fi
7270
7271
7272
7273 if test -n "$AS"; then
7274   ac_cv_prog_AS=$AS
7275 elif test -n "$ac_cv_prog_AS"; then
7276   AS=$ac_cv_prog_AS
7277 fi
7278
7279 if test -n "$ac_cv_prog_AS"; then
7280   for ncn_progname in as; do
7281     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7282 set dummy ${ncn_progname}; ac_word=$2
7283 echo "$as_me:$LINENO: checking for $ac_word" >&5
7284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7285 if test "${ac_cv_prog_AS+set}" = set; then
7286   echo $ECHO_N "(cached) $ECHO_C" >&6
7287 else
7288   if test -n "$AS"; then
7289   ac_cv_prog_AS="$AS" # Let the user override the test.
7290 else
7291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7292 for as_dir in $PATH
7293 do
7294   IFS=$as_save_IFS
7295   test -z "$as_dir" && as_dir=.
7296   for ac_exec_ext in '' $ac_executable_extensions; do
7297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7298     ac_cv_prog_AS="${ncn_progname}"
7299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7300     break 2
7301   fi
7302 done
7303 done
7304
7305 fi
7306 fi
7307 AS=$ac_cv_prog_AS
7308 if test -n "$AS"; then
7309   echo "$as_me:$LINENO: result: $AS" >&5
7310 echo "${ECHO_T}$AS" >&6
7311 else
7312   echo "$as_me:$LINENO: result: no" >&5
7313 echo "${ECHO_T}no" >&6
7314 fi
7315
7316   done
7317 fi
7318
7319 for ncn_progname in as; do
7320   if test -n "$ncn_tool_prefix"; then
7321     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7322 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7323 echo "$as_me:$LINENO: checking for $ac_word" >&5
7324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7325 if test "${ac_cv_prog_AS+set}" = set; then
7326   echo $ECHO_N "(cached) $ECHO_C" >&6
7327 else
7328   if test -n "$AS"; then
7329   ac_cv_prog_AS="$AS" # Let the user override the test.
7330 else
7331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7332 for as_dir in $PATH
7333 do
7334   IFS=$as_save_IFS
7335   test -z "$as_dir" && as_dir=.
7336   for ac_exec_ext in '' $ac_executable_extensions; do
7337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7338     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7340     break 2
7341   fi
7342 done
7343 done
7344
7345 fi
7346 fi
7347 AS=$ac_cv_prog_AS
7348 if test -n "$AS"; then
7349   echo "$as_me:$LINENO: result: $AS" >&5
7350 echo "${ECHO_T}$AS" >&6
7351 else
7352   echo "$as_me:$LINENO: result: no" >&5
7353 echo "${ECHO_T}no" >&6
7354 fi
7355
7356   fi
7357   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7358     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7359 set dummy ${ncn_progname}; ac_word=$2
7360 echo "$as_me:$LINENO: checking for $ac_word" >&5
7361 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7362 if test "${ac_cv_prog_AS+set}" = set; then
7363   echo $ECHO_N "(cached) $ECHO_C" >&6
7364 else
7365   if test -n "$AS"; then
7366   ac_cv_prog_AS="$AS" # Let the user override the test.
7367 else
7368 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7369 for as_dir in $PATH
7370 do
7371   IFS=$as_save_IFS
7372   test -z "$as_dir" && as_dir=.
7373   for ac_exec_ext in '' $ac_executable_extensions; do
7374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7375     ac_cv_prog_AS="${ncn_progname}"
7376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7377     break 2
7378   fi
7379 done
7380 done
7381
7382 fi
7383 fi
7384 AS=$ac_cv_prog_AS
7385 if test -n "$AS"; then
7386   echo "$as_me:$LINENO: result: $AS" >&5
7387 echo "${ECHO_T}$AS" >&6
7388 else
7389   echo "$as_me:$LINENO: result: no" >&5
7390 echo "${ECHO_T}no" >&6
7391 fi
7392
7393   fi
7394   test -n "$ac_cv_prog_AS" && break
7395 done
7396
7397 if test -z "$ac_cv_prog_AS" ; then
7398   set dummy as
7399   if test $build = $host ; then
7400     AS="$2"
7401   else
7402     AS="${ncn_tool_prefix}$2"
7403   fi
7404 fi
7405
7406
7407
7408 if test -n "$DLLTOOL"; then
7409   ac_cv_prog_DLLTOOL=$DLLTOOL
7410 elif test -n "$ac_cv_prog_DLLTOOL"; then
7411   DLLTOOL=$ac_cv_prog_DLLTOOL
7412 fi
7413
7414 if test -n "$ac_cv_prog_DLLTOOL"; then
7415   for ncn_progname in dlltool; do
7416     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7417 set dummy ${ncn_progname}; ac_word=$2
7418 echo "$as_me:$LINENO: checking for $ac_word" >&5
7419 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7420 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7421   echo $ECHO_N "(cached) $ECHO_C" >&6
7422 else
7423   if test -n "$DLLTOOL"; then
7424   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7425 else
7426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7427 for as_dir in $PATH
7428 do
7429   IFS=$as_save_IFS
7430   test -z "$as_dir" && as_dir=.
7431   for ac_exec_ext in '' $ac_executable_extensions; do
7432   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7433     ac_cv_prog_DLLTOOL="${ncn_progname}"
7434     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7435     break 2
7436   fi
7437 done
7438 done
7439
7440 fi
7441 fi
7442 DLLTOOL=$ac_cv_prog_DLLTOOL
7443 if test -n "$DLLTOOL"; then
7444   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7445 echo "${ECHO_T}$DLLTOOL" >&6
7446 else
7447   echo "$as_me:$LINENO: result: no" >&5
7448 echo "${ECHO_T}no" >&6
7449 fi
7450
7451   done
7452 fi
7453
7454 for ncn_progname in dlltool; do
7455   if test -n "$ncn_tool_prefix"; then
7456     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7457 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7458 echo "$as_me:$LINENO: checking for $ac_word" >&5
7459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7460 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7461   echo $ECHO_N "(cached) $ECHO_C" >&6
7462 else
7463   if test -n "$DLLTOOL"; then
7464   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7465 else
7466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7467 for as_dir in $PATH
7468 do
7469   IFS=$as_save_IFS
7470   test -z "$as_dir" && as_dir=.
7471   for ac_exec_ext in '' $ac_executable_extensions; do
7472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7473     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7475     break 2
7476   fi
7477 done
7478 done
7479
7480 fi
7481 fi
7482 DLLTOOL=$ac_cv_prog_DLLTOOL
7483 if test -n "$DLLTOOL"; then
7484   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7485 echo "${ECHO_T}$DLLTOOL" >&6
7486 else
7487   echo "$as_me:$LINENO: result: no" >&5
7488 echo "${ECHO_T}no" >&6
7489 fi
7490
7491   fi
7492   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7493     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7494 set dummy ${ncn_progname}; ac_word=$2
7495 echo "$as_me:$LINENO: checking for $ac_word" >&5
7496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7497 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7498   echo $ECHO_N "(cached) $ECHO_C" >&6
7499 else
7500   if test -n "$DLLTOOL"; then
7501   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7502 else
7503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7504 for as_dir in $PATH
7505 do
7506   IFS=$as_save_IFS
7507   test -z "$as_dir" && as_dir=.
7508   for ac_exec_ext in '' $ac_executable_extensions; do
7509   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7510     ac_cv_prog_DLLTOOL="${ncn_progname}"
7511     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7512     break 2
7513   fi
7514 done
7515 done
7516
7517 fi
7518 fi
7519 DLLTOOL=$ac_cv_prog_DLLTOOL
7520 if test -n "$DLLTOOL"; then
7521   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7522 echo "${ECHO_T}$DLLTOOL" >&6
7523 else
7524   echo "$as_me:$LINENO: result: no" >&5
7525 echo "${ECHO_T}no" >&6
7526 fi
7527
7528   fi
7529   test -n "$ac_cv_prog_DLLTOOL" && break
7530 done
7531
7532 if test -z "$ac_cv_prog_DLLTOOL" ; then
7533   set dummy dlltool
7534   if test $build = $host ; then
7535     DLLTOOL="$2"
7536   else
7537     DLLTOOL="${ncn_tool_prefix}$2"
7538   fi
7539 fi
7540
7541
7542
7543 if test -n "$LD"; then
7544   ac_cv_prog_LD=$LD
7545 elif test -n "$ac_cv_prog_LD"; then
7546   LD=$ac_cv_prog_LD
7547 fi
7548
7549 if test -n "$ac_cv_prog_LD"; then
7550   for ncn_progname in ld; do
7551     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7552 set dummy ${ncn_progname}; ac_word=$2
7553 echo "$as_me:$LINENO: checking for $ac_word" >&5
7554 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7555 if test "${ac_cv_prog_LD+set}" = set; then
7556   echo $ECHO_N "(cached) $ECHO_C" >&6
7557 else
7558   if test -n "$LD"; then
7559   ac_cv_prog_LD="$LD" # Let the user override the test.
7560 else
7561 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7562 for as_dir in $PATH
7563 do
7564   IFS=$as_save_IFS
7565   test -z "$as_dir" && as_dir=.
7566   for ac_exec_ext in '' $ac_executable_extensions; do
7567   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7568     ac_cv_prog_LD="${ncn_progname}"
7569     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7570     break 2
7571   fi
7572 done
7573 done
7574
7575 fi
7576 fi
7577 LD=$ac_cv_prog_LD
7578 if test -n "$LD"; then
7579   echo "$as_me:$LINENO: result: $LD" >&5
7580 echo "${ECHO_T}$LD" >&6
7581 else
7582   echo "$as_me:$LINENO: result: no" >&5
7583 echo "${ECHO_T}no" >&6
7584 fi
7585
7586   done
7587 fi
7588
7589 for ncn_progname in ld; do
7590   if test -n "$ncn_tool_prefix"; then
7591     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7592 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7593 echo "$as_me:$LINENO: checking for $ac_word" >&5
7594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7595 if test "${ac_cv_prog_LD+set}" = set; then
7596   echo $ECHO_N "(cached) $ECHO_C" >&6
7597 else
7598   if test -n "$LD"; then
7599   ac_cv_prog_LD="$LD" # Let the user override the test.
7600 else
7601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7602 for as_dir in $PATH
7603 do
7604   IFS=$as_save_IFS
7605   test -z "$as_dir" && as_dir=.
7606   for ac_exec_ext in '' $ac_executable_extensions; do
7607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7608     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7610     break 2
7611   fi
7612 done
7613 done
7614
7615 fi
7616 fi
7617 LD=$ac_cv_prog_LD
7618 if test -n "$LD"; then
7619   echo "$as_me:$LINENO: result: $LD" >&5
7620 echo "${ECHO_T}$LD" >&6
7621 else
7622   echo "$as_me:$LINENO: result: no" >&5
7623 echo "${ECHO_T}no" >&6
7624 fi
7625
7626   fi
7627   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7628     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7629 set dummy ${ncn_progname}; ac_word=$2
7630 echo "$as_me:$LINENO: checking for $ac_word" >&5
7631 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7632 if test "${ac_cv_prog_LD+set}" = set; then
7633   echo $ECHO_N "(cached) $ECHO_C" >&6
7634 else
7635   if test -n "$LD"; then
7636   ac_cv_prog_LD="$LD" # Let the user override the test.
7637 else
7638 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7639 for as_dir in $PATH
7640 do
7641   IFS=$as_save_IFS
7642   test -z "$as_dir" && as_dir=.
7643   for ac_exec_ext in '' $ac_executable_extensions; do
7644   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7645     ac_cv_prog_LD="${ncn_progname}"
7646     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7647     break 2
7648   fi
7649 done
7650 done
7651
7652 fi
7653 fi
7654 LD=$ac_cv_prog_LD
7655 if test -n "$LD"; then
7656   echo "$as_me:$LINENO: result: $LD" >&5
7657 echo "${ECHO_T}$LD" >&6
7658 else
7659   echo "$as_me:$LINENO: result: no" >&5
7660 echo "${ECHO_T}no" >&6
7661 fi
7662
7663   fi
7664   test -n "$ac_cv_prog_LD" && break
7665 done
7666
7667 if test -z "$ac_cv_prog_LD" ; then
7668   set dummy ld
7669   if test $build = $host ; then
7670     LD="$2"
7671   else
7672     LD="${ncn_tool_prefix}$2"
7673   fi
7674 fi
7675
7676
7677
7678 if test -n "$LIPO"; then
7679   ac_cv_prog_LIPO=$LIPO
7680 elif test -n "$ac_cv_prog_LIPO"; then
7681   LIPO=$ac_cv_prog_LIPO
7682 fi
7683
7684 if test -n "$ac_cv_prog_LIPO"; then
7685   for ncn_progname in lipo; do
7686     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7687 set dummy ${ncn_progname}; ac_word=$2
7688 echo "$as_me:$LINENO: checking for $ac_word" >&5
7689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7690 if test "${ac_cv_prog_LIPO+set}" = set; then
7691   echo $ECHO_N "(cached) $ECHO_C" >&6
7692 else
7693   if test -n "$LIPO"; then
7694   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7695 else
7696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7697 for as_dir in $PATH
7698 do
7699   IFS=$as_save_IFS
7700   test -z "$as_dir" && as_dir=.
7701   for ac_exec_ext in '' $ac_executable_extensions; do
7702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7703     ac_cv_prog_LIPO="${ncn_progname}"
7704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7705     break 2
7706   fi
7707 done
7708 done
7709
7710 fi
7711 fi
7712 LIPO=$ac_cv_prog_LIPO
7713 if test -n "$LIPO"; then
7714   echo "$as_me:$LINENO: result: $LIPO" >&5
7715 echo "${ECHO_T}$LIPO" >&6
7716 else
7717   echo "$as_me:$LINENO: result: no" >&5
7718 echo "${ECHO_T}no" >&6
7719 fi
7720
7721   done
7722 fi
7723
7724 for ncn_progname in lipo; do
7725   if test -n "$ncn_tool_prefix"; then
7726     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7727 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7728 echo "$as_me:$LINENO: checking for $ac_word" >&5
7729 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7730 if test "${ac_cv_prog_LIPO+set}" = set; then
7731   echo $ECHO_N "(cached) $ECHO_C" >&6
7732 else
7733   if test -n "$LIPO"; then
7734   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7735 else
7736 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7737 for as_dir in $PATH
7738 do
7739   IFS=$as_save_IFS
7740   test -z "$as_dir" && as_dir=.
7741   for ac_exec_ext in '' $ac_executable_extensions; do
7742   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7743     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7744     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7745     break 2
7746   fi
7747 done
7748 done
7749
7750 fi
7751 fi
7752 LIPO=$ac_cv_prog_LIPO
7753 if test -n "$LIPO"; then
7754   echo "$as_me:$LINENO: result: $LIPO" >&5
7755 echo "${ECHO_T}$LIPO" >&6
7756 else
7757   echo "$as_me:$LINENO: result: no" >&5
7758 echo "${ECHO_T}no" >&6
7759 fi
7760
7761   fi
7762   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7763     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7764 set dummy ${ncn_progname}; ac_word=$2
7765 echo "$as_me:$LINENO: checking for $ac_word" >&5
7766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7767 if test "${ac_cv_prog_LIPO+set}" = set; then
7768   echo $ECHO_N "(cached) $ECHO_C" >&6
7769 else
7770   if test -n "$LIPO"; then
7771   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7772 else
7773 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7774 for as_dir in $PATH
7775 do
7776   IFS=$as_save_IFS
7777   test -z "$as_dir" && as_dir=.
7778   for ac_exec_ext in '' $ac_executable_extensions; do
7779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7780     ac_cv_prog_LIPO="${ncn_progname}"
7781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7782     break 2
7783   fi
7784 done
7785 done
7786
7787 fi
7788 fi
7789 LIPO=$ac_cv_prog_LIPO
7790 if test -n "$LIPO"; then
7791   echo "$as_me:$LINENO: result: $LIPO" >&5
7792 echo "${ECHO_T}$LIPO" >&6
7793 else
7794   echo "$as_me:$LINENO: result: no" >&5
7795 echo "${ECHO_T}no" >&6
7796 fi
7797
7798   fi
7799   test -n "$ac_cv_prog_LIPO" && break
7800 done
7801
7802 if test -z "$ac_cv_prog_LIPO" ; then
7803   set dummy lipo
7804   if test $build = $host ; then
7805     LIPO="$2"
7806   else
7807     LIPO="${ncn_tool_prefix}$2"
7808   fi
7809 fi
7810
7811
7812
7813 if test -n "$NM"; then
7814   ac_cv_prog_NM=$NM
7815 elif test -n "$ac_cv_prog_NM"; then
7816   NM=$ac_cv_prog_NM
7817 fi
7818
7819 if test -n "$ac_cv_prog_NM"; then
7820   for ncn_progname in nm; do
7821     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7822 set dummy ${ncn_progname}; ac_word=$2
7823 echo "$as_me:$LINENO: checking for $ac_word" >&5
7824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7825 if test "${ac_cv_prog_NM+set}" = set; then
7826   echo $ECHO_N "(cached) $ECHO_C" >&6
7827 else
7828   if test -n "$NM"; then
7829   ac_cv_prog_NM="$NM" # Let the user override the test.
7830 else
7831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7832 for as_dir in $PATH
7833 do
7834   IFS=$as_save_IFS
7835   test -z "$as_dir" && as_dir=.
7836   for ac_exec_ext in '' $ac_executable_extensions; do
7837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7838     ac_cv_prog_NM="${ncn_progname}"
7839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7840     break 2
7841   fi
7842 done
7843 done
7844
7845 fi
7846 fi
7847 NM=$ac_cv_prog_NM
7848 if test -n "$NM"; then
7849   echo "$as_me:$LINENO: result: $NM" >&5
7850 echo "${ECHO_T}$NM" >&6
7851 else
7852   echo "$as_me:$LINENO: result: no" >&5
7853 echo "${ECHO_T}no" >&6
7854 fi
7855
7856   done
7857 fi
7858
7859 for ncn_progname in nm; do
7860   if test -n "$ncn_tool_prefix"; then
7861     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7862 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7863 echo "$as_me:$LINENO: checking for $ac_word" >&5
7864 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7865 if test "${ac_cv_prog_NM+set}" = set; then
7866   echo $ECHO_N "(cached) $ECHO_C" >&6
7867 else
7868   if test -n "$NM"; then
7869   ac_cv_prog_NM="$NM" # Let the user override the test.
7870 else
7871 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7872 for as_dir in $PATH
7873 do
7874   IFS=$as_save_IFS
7875   test -z "$as_dir" && as_dir=.
7876   for ac_exec_ext in '' $ac_executable_extensions; do
7877   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7878     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7879     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7880     break 2
7881   fi
7882 done
7883 done
7884
7885 fi
7886 fi
7887 NM=$ac_cv_prog_NM
7888 if test -n "$NM"; then
7889   echo "$as_me:$LINENO: result: $NM" >&5
7890 echo "${ECHO_T}$NM" >&6
7891 else
7892   echo "$as_me:$LINENO: result: no" >&5
7893 echo "${ECHO_T}no" >&6
7894 fi
7895
7896   fi
7897   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7898     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7899 set dummy ${ncn_progname}; ac_word=$2
7900 echo "$as_me:$LINENO: checking for $ac_word" >&5
7901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7902 if test "${ac_cv_prog_NM+set}" = set; then
7903   echo $ECHO_N "(cached) $ECHO_C" >&6
7904 else
7905   if test -n "$NM"; then
7906   ac_cv_prog_NM="$NM" # Let the user override the test.
7907 else
7908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7909 for as_dir in $PATH
7910 do
7911   IFS=$as_save_IFS
7912   test -z "$as_dir" && as_dir=.
7913   for ac_exec_ext in '' $ac_executable_extensions; do
7914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7915     ac_cv_prog_NM="${ncn_progname}"
7916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7917     break 2
7918   fi
7919 done
7920 done
7921
7922 fi
7923 fi
7924 NM=$ac_cv_prog_NM
7925 if test -n "$NM"; then
7926   echo "$as_me:$LINENO: result: $NM" >&5
7927 echo "${ECHO_T}$NM" >&6
7928 else
7929   echo "$as_me:$LINENO: result: no" >&5
7930 echo "${ECHO_T}no" >&6
7931 fi
7932
7933   fi
7934   test -n "$ac_cv_prog_NM" && break
7935 done
7936
7937 if test -z "$ac_cv_prog_NM" ; then
7938   set dummy nm
7939   if test $build = $host ; then
7940     NM="$2"
7941   else
7942     NM="${ncn_tool_prefix}$2"
7943   fi
7944 fi
7945
7946
7947
7948 if test -n "$RANLIB"; then
7949   ac_cv_prog_RANLIB=$RANLIB
7950 elif test -n "$ac_cv_prog_RANLIB"; then
7951   RANLIB=$ac_cv_prog_RANLIB
7952 fi
7953
7954 if test -n "$ac_cv_prog_RANLIB"; then
7955   for ncn_progname in ranlib; do
7956     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7957 set dummy ${ncn_progname}; ac_word=$2
7958 echo "$as_me:$LINENO: checking for $ac_word" >&5
7959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7960 if test "${ac_cv_prog_RANLIB+set}" = set; then
7961   echo $ECHO_N "(cached) $ECHO_C" >&6
7962 else
7963   if test -n "$RANLIB"; then
7964   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7965 else
7966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7967 for as_dir in $PATH
7968 do
7969   IFS=$as_save_IFS
7970   test -z "$as_dir" && as_dir=.
7971   for ac_exec_ext in '' $ac_executable_extensions; do
7972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7973     ac_cv_prog_RANLIB="${ncn_progname}"
7974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7975     break 2
7976   fi
7977 done
7978 done
7979
7980 fi
7981 fi
7982 RANLIB=$ac_cv_prog_RANLIB
7983 if test -n "$RANLIB"; then
7984   echo "$as_me:$LINENO: result: $RANLIB" >&5
7985 echo "${ECHO_T}$RANLIB" >&6
7986 else
7987   echo "$as_me:$LINENO: result: no" >&5
7988 echo "${ECHO_T}no" >&6
7989 fi
7990
7991   done
7992 fi
7993
7994 for ncn_progname in ranlib; do
7995   if test -n "$ncn_tool_prefix"; then
7996     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7997 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7998 echo "$as_me:$LINENO: checking for $ac_word" >&5
7999 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8000 if test "${ac_cv_prog_RANLIB+set}" = set; then
8001   echo $ECHO_N "(cached) $ECHO_C" >&6
8002 else
8003   if test -n "$RANLIB"; then
8004   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8005 else
8006 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8007 for as_dir in $PATH
8008 do
8009   IFS=$as_save_IFS
8010   test -z "$as_dir" && as_dir=.
8011   for ac_exec_ext in '' $ac_executable_extensions; do
8012   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8013     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
8014     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8015     break 2
8016   fi
8017 done
8018 done
8019
8020 fi
8021 fi
8022 RANLIB=$ac_cv_prog_RANLIB
8023 if test -n "$RANLIB"; then
8024   echo "$as_me:$LINENO: result: $RANLIB" >&5
8025 echo "${ECHO_T}$RANLIB" >&6
8026 else
8027   echo "$as_me:$LINENO: result: no" >&5
8028 echo "${ECHO_T}no" >&6
8029 fi
8030
8031   fi
8032   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
8033     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8034 set dummy ${ncn_progname}; ac_word=$2
8035 echo "$as_me:$LINENO: checking for $ac_word" >&5
8036 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8037 if test "${ac_cv_prog_RANLIB+set}" = set; then
8038   echo $ECHO_N "(cached) $ECHO_C" >&6
8039 else
8040   if test -n "$RANLIB"; then
8041   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8042 else
8043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8044 for as_dir in $PATH
8045 do
8046   IFS=$as_save_IFS
8047   test -z "$as_dir" && as_dir=.
8048   for ac_exec_ext in '' $ac_executable_extensions; do
8049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8050     ac_cv_prog_RANLIB="${ncn_progname}"
8051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8052     break 2
8053   fi
8054 done
8055 done
8056
8057 fi
8058 fi
8059 RANLIB=$ac_cv_prog_RANLIB
8060 if test -n "$RANLIB"; then
8061   echo "$as_me:$LINENO: result: $RANLIB" >&5
8062 echo "${ECHO_T}$RANLIB" >&6
8063 else
8064   echo "$as_me:$LINENO: result: no" >&5
8065 echo "${ECHO_T}no" >&6
8066 fi
8067
8068   fi
8069   test -n "$ac_cv_prog_RANLIB" && break
8070 done
8071
8072 if test -z "$ac_cv_prog_RANLIB" ; then
8073   RANLIB=":"
8074 fi
8075
8076
8077
8078 if test -n "$STRIP"; then
8079   ac_cv_prog_STRIP=$STRIP
8080 elif test -n "$ac_cv_prog_STRIP"; then
8081   STRIP=$ac_cv_prog_STRIP
8082 fi
8083
8084 if test -n "$ac_cv_prog_STRIP"; then
8085   for ncn_progname in strip; do
8086     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8087 set dummy ${ncn_progname}; ac_word=$2
8088 echo "$as_me:$LINENO: checking for $ac_word" >&5
8089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8090 if test "${ac_cv_prog_STRIP+set}" = set; then
8091   echo $ECHO_N "(cached) $ECHO_C" >&6
8092 else
8093   if test -n "$STRIP"; then
8094   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8095 else
8096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8097 for as_dir in $PATH
8098 do
8099   IFS=$as_save_IFS
8100   test -z "$as_dir" && as_dir=.
8101   for ac_exec_ext in '' $ac_executable_extensions; do
8102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8103     ac_cv_prog_STRIP="${ncn_progname}"
8104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8105     break 2
8106   fi
8107 done
8108 done
8109
8110 fi
8111 fi
8112 STRIP=$ac_cv_prog_STRIP
8113 if test -n "$STRIP"; then
8114   echo "$as_me:$LINENO: result: $STRIP" >&5
8115 echo "${ECHO_T}$STRIP" >&6
8116 else
8117   echo "$as_me:$LINENO: result: no" >&5
8118 echo "${ECHO_T}no" >&6
8119 fi
8120
8121   done
8122 fi
8123
8124 for ncn_progname in strip; do
8125   if test -n "$ncn_tool_prefix"; then
8126     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8127 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8128 echo "$as_me:$LINENO: checking for $ac_word" >&5
8129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8130 if test "${ac_cv_prog_STRIP+set}" = set; then
8131   echo $ECHO_N "(cached) $ECHO_C" >&6
8132 else
8133   if test -n "$STRIP"; then
8134   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8135 else
8136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8137 for as_dir in $PATH
8138 do
8139   IFS=$as_save_IFS
8140   test -z "$as_dir" && as_dir=.
8141   for ac_exec_ext in '' $ac_executable_extensions; do
8142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8143     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8145     break 2
8146   fi
8147 done
8148 done
8149
8150 fi
8151 fi
8152 STRIP=$ac_cv_prog_STRIP
8153 if test -n "$STRIP"; then
8154   echo "$as_me:$LINENO: result: $STRIP" >&5
8155 echo "${ECHO_T}$STRIP" >&6
8156 else
8157   echo "$as_me:$LINENO: result: no" >&5
8158 echo "${ECHO_T}no" >&6
8159 fi
8160
8161   fi
8162   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8163     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8164 set dummy ${ncn_progname}; ac_word=$2
8165 echo "$as_me:$LINENO: checking for $ac_word" >&5
8166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8167 if test "${ac_cv_prog_STRIP+set}" = set; then
8168   echo $ECHO_N "(cached) $ECHO_C" >&6
8169 else
8170   if test -n "$STRIP"; then
8171   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8172 else
8173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8174 for as_dir in $PATH
8175 do
8176   IFS=$as_save_IFS
8177   test -z "$as_dir" && as_dir=.
8178   for ac_exec_ext in '' $ac_executable_extensions; do
8179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8180     ac_cv_prog_STRIP="${ncn_progname}"
8181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8182     break 2
8183   fi
8184 done
8185 done
8186
8187 fi
8188 fi
8189 STRIP=$ac_cv_prog_STRIP
8190 if test -n "$STRIP"; then
8191   echo "$as_me:$LINENO: result: $STRIP" >&5
8192 echo "${ECHO_T}$STRIP" >&6
8193 else
8194   echo "$as_me:$LINENO: result: no" >&5
8195 echo "${ECHO_T}no" >&6
8196 fi
8197
8198   fi
8199   test -n "$ac_cv_prog_STRIP" && break
8200 done
8201
8202 if test -z "$ac_cv_prog_STRIP" ; then
8203   STRIP=":"
8204 fi
8205
8206
8207
8208 if test -n "$WINDRES"; then
8209   ac_cv_prog_WINDRES=$WINDRES
8210 elif test -n "$ac_cv_prog_WINDRES"; then
8211   WINDRES=$ac_cv_prog_WINDRES
8212 fi
8213
8214 if test -n "$ac_cv_prog_WINDRES"; then
8215   for ncn_progname in windres; do
8216     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8217 set dummy ${ncn_progname}; ac_word=$2
8218 echo "$as_me:$LINENO: checking for $ac_word" >&5
8219 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8220 if test "${ac_cv_prog_WINDRES+set}" = set; then
8221   echo $ECHO_N "(cached) $ECHO_C" >&6
8222 else
8223   if test -n "$WINDRES"; then
8224   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8225 else
8226 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8227 for as_dir in $PATH
8228 do
8229   IFS=$as_save_IFS
8230   test -z "$as_dir" && as_dir=.
8231   for ac_exec_ext in '' $ac_executable_extensions; do
8232   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8233     ac_cv_prog_WINDRES="${ncn_progname}"
8234     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8235     break 2
8236   fi
8237 done
8238 done
8239
8240 fi
8241 fi
8242 WINDRES=$ac_cv_prog_WINDRES
8243 if test -n "$WINDRES"; then
8244   echo "$as_me:$LINENO: result: $WINDRES" >&5
8245 echo "${ECHO_T}$WINDRES" >&6
8246 else
8247   echo "$as_me:$LINENO: result: no" >&5
8248 echo "${ECHO_T}no" >&6
8249 fi
8250
8251   done
8252 fi
8253
8254 for ncn_progname in windres; do
8255   if test -n "$ncn_tool_prefix"; then
8256     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8257 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8258 echo "$as_me:$LINENO: checking for $ac_word" >&5
8259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8260 if test "${ac_cv_prog_WINDRES+set}" = set; then
8261   echo $ECHO_N "(cached) $ECHO_C" >&6
8262 else
8263   if test -n "$WINDRES"; then
8264   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8265 else
8266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8267 for as_dir in $PATH
8268 do
8269   IFS=$as_save_IFS
8270   test -z "$as_dir" && as_dir=.
8271   for ac_exec_ext in '' $ac_executable_extensions; do
8272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8273     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8275     break 2
8276   fi
8277 done
8278 done
8279
8280 fi
8281 fi
8282 WINDRES=$ac_cv_prog_WINDRES
8283 if test -n "$WINDRES"; then
8284   echo "$as_me:$LINENO: result: $WINDRES" >&5
8285 echo "${ECHO_T}$WINDRES" >&6
8286 else
8287   echo "$as_me:$LINENO: result: no" >&5
8288 echo "${ECHO_T}no" >&6
8289 fi
8290
8291   fi
8292   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8293     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8294 set dummy ${ncn_progname}; ac_word=$2
8295 echo "$as_me:$LINENO: checking for $ac_word" >&5
8296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8297 if test "${ac_cv_prog_WINDRES+set}" = set; then
8298   echo $ECHO_N "(cached) $ECHO_C" >&6
8299 else
8300   if test -n "$WINDRES"; then
8301   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8302 else
8303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8304 for as_dir in $PATH
8305 do
8306   IFS=$as_save_IFS
8307   test -z "$as_dir" && as_dir=.
8308   for ac_exec_ext in '' $ac_executable_extensions; do
8309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8310     ac_cv_prog_WINDRES="${ncn_progname}"
8311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8312     break 2
8313   fi
8314 done
8315 done
8316
8317 fi
8318 fi
8319 WINDRES=$ac_cv_prog_WINDRES
8320 if test -n "$WINDRES"; then
8321   echo "$as_me:$LINENO: result: $WINDRES" >&5
8322 echo "${ECHO_T}$WINDRES" >&6
8323 else
8324   echo "$as_me:$LINENO: result: no" >&5
8325 echo "${ECHO_T}no" >&6
8326 fi
8327
8328   fi
8329   test -n "$ac_cv_prog_WINDRES" && break
8330 done
8331
8332 if test -z "$ac_cv_prog_WINDRES" ; then
8333   set dummy windres
8334   if test $build = $host ; then
8335     WINDRES="$2"
8336   else
8337     WINDRES="${ncn_tool_prefix}$2"
8338   fi
8339 fi
8340
8341
8342
8343 if test -n "$WINDMC"; then
8344   ac_cv_prog_WINDMC=$WINDMC
8345 elif test -n "$ac_cv_prog_WINDMC"; then
8346   WINDMC=$ac_cv_prog_WINDMC
8347 fi
8348
8349 if test -n "$ac_cv_prog_WINDMC"; then
8350   for ncn_progname in windmc; do
8351     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8352 set dummy ${ncn_progname}; ac_word=$2
8353 echo "$as_me:$LINENO: checking for $ac_word" >&5
8354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8355 if test "${ac_cv_prog_WINDMC+set}" = set; then
8356   echo $ECHO_N "(cached) $ECHO_C" >&6
8357 else
8358   if test -n "$WINDMC"; then
8359   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8360 else
8361 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8362 for as_dir in $PATH
8363 do
8364   IFS=$as_save_IFS
8365   test -z "$as_dir" && as_dir=.
8366   for ac_exec_ext in '' $ac_executable_extensions; do
8367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8368     ac_cv_prog_WINDMC="${ncn_progname}"
8369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8370     break 2
8371   fi
8372 done
8373 done
8374
8375 fi
8376 fi
8377 WINDMC=$ac_cv_prog_WINDMC
8378 if test -n "$WINDMC"; then
8379   echo "$as_me:$LINENO: result: $WINDMC" >&5
8380 echo "${ECHO_T}$WINDMC" >&6
8381 else
8382   echo "$as_me:$LINENO: result: no" >&5
8383 echo "${ECHO_T}no" >&6
8384 fi
8385
8386   done
8387 fi
8388
8389 for ncn_progname in windmc; do
8390   if test -n "$ncn_tool_prefix"; then
8391     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8392 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8393 echo "$as_me:$LINENO: checking for $ac_word" >&5
8394 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8395 if test "${ac_cv_prog_WINDMC+set}" = set; then
8396   echo $ECHO_N "(cached) $ECHO_C" >&6
8397 else
8398   if test -n "$WINDMC"; then
8399   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8400 else
8401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8402 for as_dir in $PATH
8403 do
8404   IFS=$as_save_IFS
8405   test -z "$as_dir" && as_dir=.
8406   for ac_exec_ext in '' $ac_executable_extensions; do
8407   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8408     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8409     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8410     break 2
8411   fi
8412 done
8413 done
8414
8415 fi
8416 fi
8417 WINDMC=$ac_cv_prog_WINDMC
8418 if test -n "$WINDMC"; then
8419   echo "$as_me:$LINENO: result: $WINDMC" >&5
8420 echo "${ECHO_T}$WINDMC" >&6
8421 else
8422   echo "$as_me:$LINENO: result: no" >&5
8423 echo "${ECHO_T}no" >&6
8424 fi
8425
8426   fi
8427   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8428     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8429 set dummy ${ncn_progname}; ac_word=$2
8430 echo "$as_me:$LINENO: checking for $ac_word" >&5
8431 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8432 if test "${ac_cv_prog_WINDMC+set}" = set; then
8433   echo $ECHO_N "(cached) $ECHO_C" >&6
8434 else
8435   if test -n "$WINDMC"; then
8436   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8437 else
8438 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8439 for as_dir in $PATH
8440 do
8441   IFS=$as_save_IFS
8442   test -z "$as_dir" && as_dir=.
8443   for ac_exec_ext in '' $ac_executable_extensions; do
8444   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8445     ac_cv_prog_WINDMC="${ncn_progname}"
8446     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8447     break 2
8448   fi
8449 done
8450 done
8451
8452 fi
8453 fi
8454 WINDMC=$ac_cv_prog_WINDMC
8455 if test -n "$WINDMC"; then
8456   echo "$as_me:$LINENO: result: $WINDMC" >&5
8457 echo "${ECHO_T}$WINDMC" >&6
8458 else
8459   echo "$as_me:$LINENO: result: no" >&5
8460 echo "${ECHO_T}no" >&6
8461 fi
8462
8463   fi
8464   test -n "$ac_cv_prog_WINDMC" && break
8465 done
8466
8467 if test -z "$ac_cv_prog_WINDMC" ; then
8468   set dummy windmc
8469   if test $build = $host ; then
8470     WINDMC="$2"
8471   else
8472     WINDMC="${ncn_tool_prefix}$2"
8473   fi
8474 fi
8475
8476
8477
8478 if test -n "$OBJCOPY"; then
8479   ac_cv_prog_OBJCOPY=$OBJCOPY
8480 elif test -n "$ac_cv_prog_OBJCOPY"; then
8481   OBJCOPY=$ac_cv_prog_OBJCOPY
8482 fi
8483
8484 if test -n "$ac_cv_prog_OBJCOPY"; then
8485   for ncn_progname in objcopy; do
8486     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8487 set dummy ${ncn_progname}; ac_word=$2
8488 echo "$as_me:$LINENO: checking for $ac_word" >&5
8489 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8490 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8491   echo $ECHO_N "(cached) $ECHO_C" >&6
8492 else
8493   if test -n "$OBJCOPY"; then
8494   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8495 else
8496 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8497 for as_dir in $PATH
8498 do
8499   IFS=$as_save_IFS
8500   test -z "$as_dir" && as_dir=.
8501   for ac_exec_ext in '' $ac_executable_extensions; do
8502   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8503     ac_cv_prog_OBJCOPY="${ncn_progname}"
8504     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8505     break 2
8506   fi
8507 done
8508 done
8509
8510 fi
8511 fi
8512 OBJCOPY=$ac_cv_prog_OBJCOPY
8513 if test -n "$OBJCOPY"; then
8514   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8515 echo "${ECHO_T}$OBJCOPY" >&6
8516 else
8517   echo "$as_me:$LINENO: result: no" >&5
8518 echo "${ECHO_T}no" >&6
8519 fi
8520
8521   done
8522 fi
8523
8524 for ncn_progname in objcopy; do
8525   if test -n "$ncn_tool_prefix"; then
8526     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8527 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8528 echo "$as_me:$LINENO: checking for $ac_word" >&5
8529 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8530 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8531   echo $ECHO_N "(cached) $ECHO_C" >&6
8532 else
8533   if test -n "$OBJCOPY"; then
8534   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8535 else
8536 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8537 for as_dir in $PATH
8538 do
8539   IFS=$as_save_IFS
8540   test -z "$as_dir" && as_dir=.
8541   for ac_exec_ext in '' $ac_executable_extensions; do
8542   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8543     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8544     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8545     break 2
8546   fi
8547 done
8548 done
8549
8550 fi
8551 fi
8552 OBJCOPY=$ac_cv_prog_OBJCOPY
8553 if test -n "$OBJCOPY"; then
8554   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8555 echo "${ECHO_T}$OBJCOPY" >&6
8556 else
8557   echo "$as_me:$LINENO: result: no" >&5
8558 echo "${ECHO_T}no" >&6
8559 fi
8560
8561   fi
8562   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8563     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8564 set dummy ${ncn_progname}; ac_word=$2
8565 echo "$as_me:$LINENO: checking for $ac_word" >&5
8566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8567 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8568   echo $ECHO_N "(cached) $ECHO_C" >&6
8569 else
8570   if test -n "$OBJCOPY"; then
8571   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8572 else
8573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8574 for as_dir in $PATH
8575 do
8576   IFS=$as_save_IFS
8577   test -z "$as_dir" && as_dir=.
8578   for ac_exec_ext in '' $ac_executable_extensions; do
8579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8580     ac_cv_prog_OBJCOPY="${ncn_progname}"
8581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8582     break 2
8583   fi
8584 done
8585 done
8586
8587 fi
8588 fi
8589 OBJCOPY=$ac_cv_prog_OBJCOPY
8590 if test -n "$OBJCOPY"; then
8591   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8592 echo "${ECHO_T}$OBJCOPY" >&6
8593 else
8594   echo "$as_me:$LINENO: result: no" >&5
8595 echo "${ECHO_T}no" >&6
8596 fi
8597
8598   fi
8599   test -n "$ac_cv_prog_OBJCOPY" && break
8600 done
8601
8602 if test -z "$ac_cv_prog_OBJCOPY" ; then
8603   set dummy objcopy
8604   if test $build = $host ; then
8605     OBJCOPY="$2"
8606   else
8607     OBJCOPY="${ncn_tool_prefix}$2"
8608   fi
8609 fi
8610
8611
8612
8613 if test -n "$OBJDUMP"; then
8614   ac_cv_prog_OBJDUMP=$OBJDUMP
8615 elif test -n "$ac_cv_prog_OBJDUMP"; then
8616   OBJDUMP=$ac_cv_prog_OBJDUMP
8617 fi
8618
8619 if test -n "$ac_cv_prog_OBJDUMP"; then
8620   for ncn_progname in objdump; do
8621     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8622 set dummy ${ncn_progname}; ac_word=$2
8623 echo "$as_me:$LINENO: checking for $ac_word" >&5
8624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8625 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8626   echo $ECHO_N "(cached) $ECHO_C" >&6
8627 else
8628   if test -n "$OBJDUMP"; then
8629   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8630 else
8631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8632 for as_dir in $PATH
8633 do
8634   IFS=$as_save_IFS
8635   test -z "$as_dir" && as_dir=.
8636   for ac_exec_ext in '' $ac_executable_extensions; do
8637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8638     ac_cv_prog_OBJDUMP="${ncn_progname}"
8639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8640     break 2
8641   fi
8642 done
8643 done
8644
8645 fi
8646 fi
8647 OBJDUMP=$ac_cv_prog_OBJDUMP
8648 if test -n "$OBJDUMP"; then
8649   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8650 echo "${ECHO_T}$OBJDUMP" >&6
8651 else
8652   echo "$as_me:$LINENO: result: no" >&5
8653 echo "${ECHO_T}no" >&6
8654 fi
8655
8656   done
8657 fi
8658
8659 for ncn_progname in objdump; do
8660   if test -n "$ncn_tool_prefix"; then
8661     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8662 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8663 echo "$as_me:$LINENO: checking for $ac_word" >&5
8664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8665 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8666   echo $ECHO_N "(cached) $ECHO_C" >&6
8667 else
8668   if test -n "$OBJDUMP"; then
8669   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8670 else
8671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8672 for as_dir in $PATH
8673 do
8674   IFS=$as_save_IFS
8675   test -z "$as_dir" && as_dir=.
8676   for ac_exec_ext in '' $ac_executable_extensions; do
8677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8678     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8680     break 2
8681   fi
8682 done
8683 done
8684
8685 fi
8686 fi
8687 OBJDUMP=$ac_cv_prog_OBJDUMP
8688 if test -n "$OBJDUMP"; then
8689   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8690 echo "${ECHO_T}$OBJDUMP" >&6
8691 else
8692   echo "$as_me:$LINENO: result: no" >&5
8693 echo "${ECHO_T}no" >&6
8694 fi
8695
8696   fi
8697   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8698     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8699 set dummy ${ncn_progname}; ac_word=$2
8700 echo "$as_me:$LINENO: checking for $ac_word" >&5
8701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8702 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8703   echo $ECHO_N "(cached) $ECHO_C" >&6
8704 else
8705   if test -n "$OBJDUMP"; then
8706   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8707 else
8708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8709 for as_dir in $PATH
8710 do
8711   IFS=$as_save_IFS
8712   test -z "$as_dir" && as_dir=.
8713   for ac_exec_ext in '' $ac_executable_extensions; do
8714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8715     ac_cv_prog_OBJDUMP="${ncn_progname}"
8716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8717     break 2
8718   fi
8719 done
8720 done
8721
8722 fi
8723 fi
8724 OBJDUMP=$ac_cv_prog_OBJDUMP
8725 if test -n "$OBJDUMP"; then
8726   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8727 echo "${ECHO_T}$OBJDUMP" >&6
8728 else
8729   echo "$as_me:$LINENO: result: no" >&5
8730 echo "${ECHO_T}no" >&6
8731 fi
8732
8733   fi
8734   test -n "$ac_cv_prog_OBJDUMP" && break
8735 done
8736
8737 if test -z "$ac_cv_prog_OBJDUMP" ; then
8738   set dummy objdump
8739   if test $build = $host ; then
8740     OBJDUMP="$2"
8741   else
8742     OBJDUMP="${ncn_tool_prefix}$2"
8743   fi
8744 fi
8745
8746
8747
8748
8749
8750
8751 # Target tools.
8752
8753 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8754 if test "${with_build_time_tools+set}" = set; then
8755   withval="$with_build_time_tools"
8756   case x"$withval" in
8757      x/*) ;;
8758      *)
8759        with_build_time_tools=
8760        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8761 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8762        ;;
8763    esac
8764 else
8765   with_build_time_tools=
8766 fi;
8767
8768
8769
8770 if test -n "$CC_FOR_TARGET"; then
8771   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8772 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8773   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8774 fi
8775
8776 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8777   for ncn_progname in cc gcc; do
8778     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8779 set dummy ${ncn_progname}; ac_word=$2
8780 echo "$as_me:$LINENO: checking for $ac_word" >&5
8781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8782 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8783   echo $ECHO_N "(cached) $ECHO_C" >&6
8784 else
8785   if test -n "$CC_FOR_TARGET"; then
8786   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8787 else
8788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8789 for as_dir in $PATH
8790 do
8791   IFS=$as_save_IFS
8792   test -z "$as_dir" && as_dir=.
8793   for ac_exec_ext in '' $ac_executable_extensions; do
8794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8795     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8797     break 2
8798   fi
8799 done
8800 done
8801
8802 fi
8803 fi
8804 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8805 if test -n "$CC_FOR_TARGET"; then
8806   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8807 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8808 else
8809   echo "$as_me:$LINENO: result: no" >&5
8810 echo "${ECHO_T}no" >&6
8811 fi
8812
8813   done
8814 fi
8815
8816 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8817   for ncn_progname in cc gcc; do
8818     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8819 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8820     if test -x $with_build_time_tools/${ncn_progname}; then
8821       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8822       echo "$as_me:$LINENO: result: yes" >&5
8823 echo "${ECHO_T}yes" >&6
8824       break
8825     else
8826       echo "$as_me:$LINENO: result: no" >&5
8827 echo "${ECHO_T}no" >&6
8828     fi
8829   done
8830 fi
8831
8832 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8833   for ncn_progname in cc gcc; do
8834     if test -n "$ncn_target_tool_prefix"; then
8835       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8836 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8837 echo "$as_me:$LINENO: checking for $ac_word" >&5
8838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8839 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8840   echo $ECHO_N "(cached) $ECHO_C" >&6
8841 else
8842   if test -n "$CC_FOR_TARGET"; then
8843   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8844 else
8845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8846 for as_dir in $PATH
8847 do
8848   IFS=$as_save_IFS
8849   test -z "$as_dir" && as_dir=.
8850   for ac_exec_ext in '' $ac_executable_extensions; do
8851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8852     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8854     break 2
8855   fi
8856 done
8857 done
8858
8859 fi
8860 fi
8861 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8862 if test -n "$CC_FOR_TARGET"; then
8863   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8864 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8865 else
8866   echo "$as_me:$LINENO: result: no" >&5
8867 echo "${ECHO_T}no" >&6
8868 fi
8869
8870     fi
8871     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8872       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8873 set dummy ${ncn_progname}; ac_word=$2
8874 echo "$as_me:$LINENO: checking for $ac_word" >&5
8875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8876 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8877   echo $ECHO_N "(cached) $ECHO_C" >&6
8878 else
8879   if test -n "$CC_FOR_TARGET"; then
8880   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8881 else
8882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8883 for as_dir in $PATH
8884 do
8885   IFS=$as_save_IFS
8886   test -z "$as_dir" && as_dir=.
8887   for ac_exec_ext in '' $ac_executable_extensions; do
8888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8889     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8891     break 2
8892   fi
8893 done
8894 done
8895
8896 fi
8897 fi
8898 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8899 if test -n "$CC_FOR_TARGET"; then
8900   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8901 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8902 else
8903   echo "$as_me:$LINENO: result: no" >&5
8904 echo "${ECHO_T}no" >&6
8905 fi
8906
8907     fi
8908     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8909   done
8910 fi
8911
8912 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8913   set dummy cc gcc
8914   if test $build = $target ; then
8915     CC_FOR_TARGET="$2"
8916   else
8917     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8918   fi
8919 else
8920   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8921 fi
8922
8923
8924
8925 if test -n "$CXX_FOR_TARGET"; then
8926   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8927 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8928   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8929 fi
8930
8931 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8932   for ncn_progname in c++ g++ cxx gxx; do
8933     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8934 set dummy ${ncn_progname}; ac_word=$2
8935 echo "$as_me:$LINENO: checking for $ac_word" >&5
8936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8937 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8938   echo $ECHO_N "(cached) $ECHO_C" >&6
8939 else
8940   if test -n "$CXX_FOR_TARGET"; then
8941   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8942 else
8943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8944 for as_dir in $PATH
8945 do
8946   IFS=$as_save_IFS
8947   test -z "$as_dir" && as_dir=.
8948   for ac_exec_ext in '' $ac_executable_extensions; do
8949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8950     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8952     break 2
8953   fi
8954 done
8955 done
8956
8957 fi
8958 fi
8959 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8960 if test -n "$CXX_FOR_TARGET"; then
8961   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8962 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8963 else
8964   echo "$as_me:$LINENO: result: no" >&5
8965 echo "${ECHO_T}no" >&6
8966 fi
8967
8968   done
8969 fi
8970
8971 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8972   for ncn_progname in c++ g++ cxx gxx; do
8973     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8974 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8975     if test -x $with_build_time_tools/${ncn_progname}; then
8976       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8977       echo "$as_me:$LINENO: result: yes" >&5
8978 echo "${ECHO_T}yes" >&6
8979       break
8980     else
8981       echo "$as_me:$LINENO: result: no" >&5
8982 echo "${ECHO_T}no" >&6
8983     fi
8984   done
8985 fi
8986
8987 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8988   for ncn_progname in c++ g++ cxx gxx; do
8989     if test -n "$ncn_target_tool_prefix"; then
8990       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8991 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8992 echo "$as_me:$LINENO: checking for $ac_word" >&5
8993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8994 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8995   echo $ECHO_N "(cached) $ECHO_C" >&6
8996 else
8997   if test -n "$CXX_FOR_TARGET"; then
8998   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8999 else
9000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9001 for as_dir in $PATH
9002 do
9003   IFS=$as_save_IFS
9004   test -z "$as_dir" && as_dir=.
9005   for ac_exec_ext in '' $ac_executable_extensions; do
9006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9007     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9009     break 2
9010   fi
9011 done
9012 done
9013
9014 fi
9015 fi
9016 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9017 if test -n "$CXX_FOR_TARGET"; then
9018   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9019 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9020 else
9021   echo "$as_me:$LINENO: result: no" >&5
9022 echo "${ECHO_T}no" >&6
9023 fi
9024
9025     fi
9026     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
9027       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9028 set dummy ${ncn_progname}; ac_word=$2
9029 echo "$as_me:$LINENO: checking for $ac_word" >&5
9030 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9031 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9032   echo $ECHO_N "(cached) $ECHO_C" >&6
9033 else
9034   if test -n "$CXX_FOR_TARGET"; then
9035   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9036 else
9037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9038 for as_dir in $PATH
9039 do
9040   IFS=$as_save_IFS
9041   test -z "$as_dir" && as_dir=.
9042   for ac_exec_ext in '' $ac_executable_extensions; do
9043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9044     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
9045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9046     break 2
9047   fi
9048 done
9049 done
9050
9051 fi
9052 fi
9053 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9054 if test -n "$CXX_FOR_TARGET"; then
9055   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9056 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9057 else
9058   echo "$as_me:$LINENO: result: no" >&5
9059 echo "${ECHO_T}no" >&6
9060 fi
9061
9062     fi
9063     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
9064   done
9065 fi
9066
9067 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
9068   set dummy c++ g++ cxx gxx
9069   if test $build = $target ; then
9070     CXX_FOR_TARGET="$2"
9071   else
9072     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
9073   fi
9074 else
9075   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
9076 fi
9077
9078
9079
9080 if test -n "$GCC_FOR_TARGET"; then
9081   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
9082 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9083   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9084 fi
9085
9086 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9087   for ncn_progname in gcc; do
9088     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9089 set dummy ${ncn_progname}; ac_word=$2
9090 echo "$as_me:$LINENO: checking for $ac_word" >&5
9091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9092 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9093   echo $ECHO_N "(cached) $ECHO_C" >&6
9094 else
9095   if test -n "$GCC_FOR_TARGET"; then
9096   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9097 else
9098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9099 for as_dir in $PATH
9100 do
9101   IFS=$as_save_IFS
9102   test -z "$as_dir" && as_dir=.
9103   for ac_exec_ext in '' $ac_executable_extensions; do
9104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9105     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9107     break 2
9108   fi
9109 done
9110 done
9111
9112 fi
9113 fi
9114 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9115 if test -n "$GCC_FOR_TARGET"; then
9116   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9117 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9118 else
9119   echo "$as_me:$LINENO: result: no" >&5
9120 echo "${ECHO_T}no" >&6
9121 fi
9122
9123   done
9124 fi
9125
9126 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9127   for ncn_progname in gcc; do
9128     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9129 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9130     if test -x $with_build_time_tools/${ncn_progname}; then
9131       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9132       echo "$as_me:$LINENO: result: yes" >&5
9133 echo "${ECHO_T}yes" >&6
9134       break
9135     else
9136       echo "$as_me:$LINENO: result: no" >&5
9137 echo "${ECHO_T}no" >&6
9138     fi
9139   done
9140 fi
9141
9142 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9143   for ncn_progname in gcc; do
9144     if test -n "$ncn_target_tool_prefix"; then
9145       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9146 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9147 echo "$as_me:$LINENO: checking for $ac_word" >&5
9148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9149 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9150   echo $ECHO_N "(cached) $ECHO_C" >&6
9151 else
9152   if test -n "$GCC_FOR_TARGET"; then
9153   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9154 else
9155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9156 for as_dir in $PATH
9157 do
9158   IFS=$as_save_IFS
9159   test -z "$as_dir" && as_dir=.
9160   for ac_exec_ext in '' $ac_executable_extensions; do
9161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9162     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9164     break 2
9165   fi
9166 done
9167 done
9168
9169 fi
9170 fi
9171 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9172 if test -n "$GCC_FOR_TARGET"; then
9173   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9174 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9175 else
9176   echo "$as_me:$LINENO: result: no" >&5
9177 echo "${ECHO_T}no" >&6
9178 fi
9179
9180     fi
9181     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9182       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9183 set dummy ${ncn_progname}; ac_word=$2
9184 echo "$as_me:$LINENO: checking for $ac_word" >&5
9185 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9186 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9187   echo $ECHO_N "(cached) $ECHO_C" >&6
9188 else
9189   if test -n "$GCC_FOR_TARGET"; then
9190   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9191 else
9192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9193 for as_dir in $PATH
9194 do
9195   IFS=$as_save_IFS
9196   test -z "$as_dir" && as_dir=.
9197   for ac_exec_ext in '' $ac_executable_extensions; do
9198   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9199     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9200     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9201     break 2
9202   fi
9203 done
9204 done
9205
9206 fi
9207 fi
9208 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9209 if test -n "$GCC_FOR_TARGET"; then
9210   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9211 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9212 else
9213   echo "$as_me:$LINENO: result: no" >&5
9214 echo "${ECHO_T}no" >&6
9215 fi
9216
9217     fi
9218     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9219   done
9220 fi
9221
9222 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9223   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9224 else
9225   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9226 fi
9227
9228
9229
9230 if test -n "$GCJ_FOR_TARGET"; then
9231   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9232 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9233   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9234 fi
9235
9236 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9237   for ncn_progname in gcj; do
9238     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9239 set dummy ${ncn_progname}; ac_word=$2
9240 echo "$as_me:$LINENO: checking for $ac_word" >&5
9241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9242 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9243   echo $ECHO_N "(cached) $ECHO_C" >&6
9244 else
9245   if test -n "$GCJ_FOR_TARGET"; then
9246   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9247 else
9248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9249 for as_dir in $PATH
9250 do
9251   IFS=$as_save_IFS
9252   test -z "$as_dir" && as_dir=.
9253   for ac_exec_ext in '' $ac_executable_extensions; do
9254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9255     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9257     break 2
9258   fi
9259 done
9260 done
9261
9262 fi
9263 fi
9264 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9265 if test -n "$GCJ_FOR_TARGET"; then
9266   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9267 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9268 else
9269   echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271 fi
9272
9273   done
9274 fi
9275
9276 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9277   for ncn_progname in gcj; do
9278     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9279 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9280     if test -x $with_build_time_tools/${ncn_progname}; then
9281       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9282       echo "$as_me:$LINENO: result: yes" >&5
9283 echo "${ECHO_T}yes" >&6
9284       break
9285     else
9286       echo "$as_me:$LINENO: result: no" >&5
9287 echo "${ECHO_T}no" >&6
9288     fi
9289   done
9290 fi
9291
9292 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9293   for ncn_progname in gcj; do
9294     if test -n "$ncn_target_tool_prefix"; then
9295       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9296 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9297 echo "$as_me:$LINENO: checking for $ac_word" >&5
9298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9299 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9300   echo $ECHO_N "(cached) $ECHO_C" >&6
9301 else
9302   if test -n "$GCJ_FOR_TARGET"; then
9303   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9304 else
9305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9306 for as_dir in $PATH
9307 do
9308   IFS=$as_save_IFS
9309   test -z "$as_dir" && as_dir=.
9310   for ac_exec_ext in '' $ac_executable_extensions; do
9311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9312     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9314     break 2
9315   fi
9316 done
9317 done
9318
9319 fi
9320 fi
9321 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9322 if test -n "$GCJ_FOR_TARGET"; then
9323   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9324 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9325 else
9326   echo "$as_me:$LINENO: result: no" >&5
9327 echo "${ECHO_T}no" >&6
9328 fi
9329
9330     fi
9331     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9332       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9333 set dummy ${ncn_progname}; ac_word=$2
9334 echo "$as_me:$LINENO: checking for $ac_word" >&5
9335 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9336 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9337   echo $ECHO_N "(cached) $ECHO_C" >&6
9338 else
9339   if test -n "$GCJ_FOR_TARGET"; then
9340   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9341 else
9342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9343 for as_dir in $PATH
9344 do
9345   IFS=$as_save_IFS
9346   test -z "$as_dir" && as_dir=.
9347   for ac_exec_ext in '' $ac_executable_extensions; do
9348   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9349     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9350     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9351     break 2
9352   fi
9353 done
9354 done
9355
9356 fi
9357 fi
9358 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9359 if test -n "$GCJ_FOR_TARGET"; then
9360   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9361 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9362 else
9363   echo "$as_me:$LINENO: result: no" >&5
9364 echo "${ECHO_T}no" >&6
9365 fi
9366
9367     fi
9368     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9369   done
9370 fi
9371
9372 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9373   set dummy gcj
9374   if test $build = $target ; then
9375     GCJ_FOR_TARGET="$2"
9376   else
9377     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9378   fi
9379 else
9380   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9381 fi
9382
9383
9384
9385 if test -n "$GFORTRAN_FOR_TARGET"; then
9386   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9387 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9388   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9389 fi
9390
9391 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9392   for ncn_progname in gfortran; do
9393     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9394 set dummy ${ncn_progname}; ac_word=$2
9395 echo "$as_me:$LINENO: checking for $ac_word" >&5
9396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9397 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9398   echo $ECHO_N "(cached) $ECHO_C" >&6
9399 else
9400   if test -n "$GFORTRAN_FOR_TARGET"; then
9401   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9402 else
9403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9404 for as_dir in $PATH
9405 do
9406   IFS=$as_save_IFS
9407   test -z "$as_dir" && as_dir=.
9408   for ac_exec_ext in '' $ac_executable_extensions; do
9409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9410     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9412     break 2
9413   fi
9414 done
9415 done
9416
9417 fi
9418 fi
9419 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9420 if test -n "$GFORTRAN_FOR_TARGET"; then
9421   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9422 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9423 else
9424   echo "$as_me:$LINENO: result: no" >&5
9425 echo "${ECHO_T}no" >&6
9426 fi
9427
9428   done
9429 fi
9430
9431 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9432   for ncn_progname in gfortran; do
9433     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9434 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9435     if test -x $with_build_time_tools/${ncn_progname}; then
9436       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9437       echo "$as_me:$LINENO: result: yes" >&5
9438 echo "${ECHO_T}yes" >&6
9439       break
9440     else
9441       echo "$as_me:$LINENO: result: no" >&5
9442 echo "${ECHO_T}no" >&6
9443     fi
9444   done
9445 fi
9446
9447 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9448   for ncn_progname in gfortran; do
9449     if test -n "$ncn_target_tool_prefix"; then
9450       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9451 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9452 echo "$as_me:$LINENO: checking for $ac_word" >&5
9453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9454 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9455   echo $ECHO_N "(cached) $ECHO_C" >&6
9456 else
9457   if test -n "$GFORTRAN_FOR_TARGET"; then
9458   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9459 else
9460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9461 for as_dir in $PATH
9462 do
9463   IFS=$as_save_IFS
9464   test -z "$as_dir" && as_dir=.
9465   for ac_exec_ext in '' $ac_executable_extensions; do
9466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9467     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9469     break 2
9470   fi
9471 done
9472 done
9473
9474 fi
9475 fi
9476 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9477 if test -n "$GFORTRAN_FOR_TARGET"; then
9478   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9479 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9480 else
9481   echo "$as_me:$LINENO: result: no" >&5
9482 echo "${ECHO_T}no" >&6
9483 fi
9484
9485     fi
9486     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9487       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9488 set dummy ${ncn_progname}; ac_word=$2
9489 echo "$as_me:$LINENO: checking for $ac_word" >&5
9490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9491 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9492   echo $ECHO_N "(cached) $ECHO_C" >&6
9493 else
9494   if test -n "$GFORTRAN_FOR_TARGET"; then
9495   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9496 else
9497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9498 for as_dir in $PATH
9499 do
9500   IFS=$as_save_IFS
9501   test -z "$as_dir" && as_dir=.
9502   for ac_exec_ext in '' $ac_executable_extensions; do
9503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9504     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9506     break 2
9507   fi
9508 done
9509 done
9510
9511 fi
9512 fi
9513 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9514 if test -n "$GFORTRAN_FOR_TARGET"; then
9515   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9516 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9517 else
9518   echo "$as_me:$LINENO: result: no" >&5
9519 echo "${ECHO_T}no" >&6
9520 fi
9521
9522     fi
9523     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9524   done
9525 fi
9526
9527 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9528   set dummy gfortran
9529   if test $build = $target ; then
9530     GFORTRAN_FOR_TARGET="$2"
9531   else
9532     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9533   fi
9534 else
9535   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9536 fi
9537
9538
9539
9540 cat > conftest.c << \EOF
9541 #ifdef __GNUC__
9542   gcc_yay;
9543 #endif
9544 EOF
9545 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9546   have_gcc_for_target=yes
9547 else
9548   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9549   have_gcc_for_target=no
9550 fi
9551 rm conftest.c
9552
9553
9554
9555
9556 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9557   if test -n "$with_build_time_tools"; then
9558     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9559 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9560     if test -x $with_build_time_tools/ar; then
9561       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9562       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9563       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9564 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9565     else
9566       echo "$as_me:$LINENO: result: no" >&5
9567 echo "${ECHO_T}no" >&6
9568     fi
9569   elif test $build != $host && test $have_gcc_for_target = yes; then
9570     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9571     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9572     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9573   fi
9574 fi
9575 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9576   # Extract the first word of "ar", so it can be a program name with args.
9577 set dummy ar; ac_word=$2
9578 echo "$as_me:$LINENO: checking for $ac_word" >&5
9579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9580 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9581   echo $ECHO_N "(cached) $ECHO_C" >&6
9582 else
9583   case $AR_FOR_TARGET in
9584   [\\/]* | ?:[\\/]*)
9585   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9586   ;;
9587   *)
9588   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9589 for as_dir in $gcc_cv_tool_dirs
9590 do
9591   IFS=$as_save_IFS
9592   test -z "$as_dir" && as_dir=.
9593   for ac_exec_ext in '' $ac_executable_extensions; do
9594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9595     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9597     break 2
9598   fi
9599 done
9600 done
9601
9602   ;;
9603 esac
9604 fi
9605 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9606
9607 if test -n "$AR_FOR_TARGET"; then
9608   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9609 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9610 else
9611   echo "$as_me:$LINENO: result: no" >&5
9612 echo "${ECHO_T}no" >&6
9613 fi
9614
9615 fi
9616 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9617
9618
9619 if test -n "$AR_FOR_TARGET"; then
9620   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9621 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9622   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9623 fi
9624
9625 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9626   for ncn_progname in ar; do
9627     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9628 set dummy ${ncn_progname}; ac_word=$2
9629 echo "$as_me:$LINENO: checking for $ac_word" >&5
9630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9631 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9632   echo $ECHO_N "(cached) $ECHO_C" >&6
9633 else
9634   if test -n "$AR_FOR_TARGET"; then
9635   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9636 else
9637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9638 for as_dir in $PATH
9639 do
9640   IFS=$as_save_IFS
9641   test -z "$as_dir" && as_dir=.
9642   for ac_exec_ext in '' $ac_executable_extensions; do
9643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9644     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9646     break 2
9647   fi
9648 done
9649 done
9650
9651 fi
9652 fi
9653 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9654 if test -n "$AR_FOR_TARGET"; then
9655   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9656 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9657 else
9658   echo "$as_me:$LINENO: result: no" >&5
9659 echo "${ECHO_T}no" >&6
9660 fi
9661
9662   done
9663 fi
9664
9665 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9666   for ncn_progname in ar; do
9667     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9668 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9669     if test -x $with_build_time_tools/${ncn_progname}; then
9670       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9671       echo "$as_me:$LINENO: result: yes" >&5
9672 echo "${ECHO_T}yes" >&6
9673       break
9674     else
9675       echo "$as_me:$LINENO: result: no" >&5
9676 echo "${ECHO_T}no" >&6
9677     fi
9678   done
9679 fi
9680
9681 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9682   for ncn_progname in ar; do
9683     if test -n "$ncn_target_tool_prefix"; then
9684       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9685 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9686 echo "$as_me:$LINENO: checking for $ac_word" >&5
9687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9688 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9689   echo $ECHO_N "(cached) $ECHO_C" >&6
9690 else
9691   if test -n "$AR_FOR_TARGET"; then
9692   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9693 else
9694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9695 for as_dir in $PATH
9696 do
9697   IFS=$as_save_IFS
9698   test -z "$as_dir" && as_dir=.
9699   for ac_exec_ext in '' $ac_executable_extensions; do
9700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9701     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9703     break 2
9704   fi
9705 done
9706 done
9707
9708 fi
9709 fi
9710 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9711 if test -n "$AR_FOR_TARGET"; then
9712   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9713 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9714 else
9715   echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717 fi
9718
9719     fi
9720     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9721       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9722 set dummy ${ncn_progname}; ac_word=$2
9723 echo "$as_me:$LINENO: checking for $ac_word" >&5
9724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9725 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9726   echo $ECHO_N "(cached) $ECHO_C" >&6
9727 else
9728   if test -n "$AR_FOR_TARGET"; then
9729   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9730 else
9731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9732 for as_dir in $PATH
9733 do
9734   IFS=$as_save_IFS
9735   test -z "$as_dir" && as_dir=.
9736   for ac_exec_ext in '' $ac_executable_extensions; do
9737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9738     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9740     break 2
9741   fi
9742 done
9743 done
9744
9745 fi
9746 fi
9747 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9748 if test -n "$AR_FOR_TARGET"; then
9749   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9750 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9751 else
9752   echo "$as_me:$LINENO: result: no" >&5
9753 echo "${ECHO_T}no" >&6
9754 fi
9755
9756     fi
9757     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9758   done
9759 fi
9760
9761 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9762   set dummy ar
9763   if test $build = $target ; then
9764     AR_FOR_TARGET="$2"
9765   else
9766     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9767   fi
9768 else
9769   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9770 fi
9771
9772 else
9773   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9774 fi
9775
9776
9777
9778
9779 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9780   if test -n "$with_build_time_tools"; then
9781     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9782 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9783     if test -x $with_build_time_tools/as; then
9784       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9785       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9786       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9787 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9788     else
9789       echo "$as_me:$LINENO: result: no" >&5
9790 echo "${ECHO_T}no" >&6
9791     fi
9792   elif test $build != $host && test $have_gcc_for_target = yes; then
9793     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9794     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9795     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9796   fi
9797 fi
9798 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9799   # Extract the first word of "as", so it can be a program name with args.
9800 set dummy as; ac_word=$2
9801 echo "$as_me:$LINENO: checking for $ac_word" >&5
9802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9803 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9804   echo $ECHO_N "(cached) $ECHO_C" >&6
9805 else
9806   case $AS_FOR_TARGET in
9807   [\\/]* | ?:[\\/]*)
9808   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9809   ;;
9810   *)
9811   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9812 for as_dir in $gcc_cv_tool_dirs
9813 do
9814   IFS=$as_save_IFS
9815   test -z "$as_dir" && as_dir=.
9816   for ac_exec_ext in '' $ac_executable_extensions; do
9817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9818     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9820     break 2
9821   fi
9822 done
9823 done
9824
9825   ;;
9826 esac
9827 fi
9828 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9829
9830 if test -n "$AS_FOR_TARGET"; then
9831   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9832 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9833 else
9834   echo "$as_me:$LINENO: result: no" >&5
9835 echo "${ECHO_T}no" >&6
9836 fi
9837
9838 fi
9839 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9840
9841
9842 if test -n "$AS_FOR_TARGET"; then
9843   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9844 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9845   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9846 fi
9847
9848 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9849   for ncn_progname in as; do
9850     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9851 set dummy ${ncn_progname}; ac_word=$2
9852 echo "$as_me:$LINENO: checking for $ac_word" >&5
9853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9854 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9855   echo $ECHO_N "(cached) $ECHO_C" >&6
9856 else
9857   if test -n "$AS_FOR_TARGET"; then
9858   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9859 else
9860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9861 for as_dir in $PATH
9862 do
9863   IFS=$as_save_IFS
9864   test -z "$as_dir" && as_dir=.
9865   for ac_exec_ext in '' $ac_executable_extensions; do
9866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9867     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9869     break 2
9870   fi
9871 done
9872 done
9873
9874 fi
9875 fi
9876 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9877 if test -n "$AS_FOR_TARGET"; then
9878   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9879 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9880 else
9881   echo "$as_me:$LINENO: result: no" >&5
9882 echo "${ECHO_T}no" >&6
9883 fi
9884
9885   done
9886 fi
9887
9888 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9889   for ncn_progname in as; do
9890     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9891 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9892     if test -x $with_build_time_tools/${ncn_progname}; then
9893       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9894       echo "$as_me:$LINENO: result: yes" >&5
9895 echo "${ECHO_T}yes" >&6
9896       break
9897     else
9898       echo "$as_me:$LINENO: result: no" >&5
9899 echo "${ECHO_T}no" >&6
9900     fi
9901   done
9902 fi
9903
9904 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9905   for ncn_progname in as; do
9906     if test -n "$ncn_target_tool_prefix"; then
9907       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9908 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9909 echo "$as_me:$LINENO: checking for $ac_word" >&5
9910 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9911 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9912   echo $ECHO_N "(cached) $ECHO_C" >&6
9913 else
9914   if test -n "$AS_FOR_TARGET"; then
9915   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9916 else
9917 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9918 for as_dir in $PATH
9919 do
9920   IFS=$as_save_IFS
9921   test -z "$as_dir" && as_dir=.
9922   for ac_exec_ext in '' $ac_executable_extensions; do
9923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9924     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9926     break 2
9927   fi
9928 done
9929 done
9930
9931 fi
9932 fi
9933 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9934 if test -n "$AS_FOR_TARGET"; then
9935   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9936 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9937 else
9938   echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940 fi
9941
9942     fi
9943     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9944       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9945 set dummy ${ncn_progname}; ac_word=$2
9946 echo "$as_me:$LINENO: checking for $ac_word" >&5
9947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9948 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9949   echo $ECHO_N "(cached) $ECHO_C" >&6
9950 else
9951   if test -n "$AS_FOR_TARGET"; then
9952   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9953 else
9954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9955 for as_dir in $PATH
9956 do
9957   IFS=$as_save_IFS
9958   test -z "$as_dir" && as_dir=.
9959   for ac_exec_ext in '' $ac_executable_extensions; do
9960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9961     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9963     break 2
9964   fi
9965 done
9966 done
9967
9968 fi
9969 fi
9970 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9971 if test -n "$AS_FOR_TARGET"; then
9972   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9973 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9974 else
9975   echo "$as_me:$LINENO: result: no" >&5
9976 echo "${ECHO_T}no" >&6
9977 fi
9978
9979     fi
9980     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9981   done
9982 fi
9983
9984 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9985   set dummy as
9986   if test $build = $target ; then
9987     AS_FOR_TARGET="$2"
9988   else
9989     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9990   fi
9991 else
9992   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9993 fi
9994
9995 else
9996   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9997 fi
9998
9999
10000
10001
10002 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10003   if test -n "$with_build_time_tools"; then
10004     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
10005 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
10006     if test -x $with_build_time_tools/dlltool; then
10007       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
10008       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10009       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
10010 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
10011     else
10012       echo "$as_me:$LINENO: result: no" >&5
10013 echo "${ECHO_T}no" >&6
10014     fi
10015   elif test $build != $host && test $have_gcc_for_target = yes; then
10016     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
10017     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
10018     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10019   fi
10020 fi
10021 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10022   # Extract the first word of "dlltool", so it can be a program name with args.
10023 set dummy dlltool; ac_word=$2
10024 echo "$as_me:$LINENO: checking for $ac_word" >&5
10025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10026 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
10027   echo $ECHO_N "(cached) $ECHO_C" >&6
10028 else
10029   case $DLLTOOL_FOR_TARGET in
10030   [\\/]* | ?:[\\/]*)
10031   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
10032   ;;
10033   *)
10034   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10035 for as_dir in $gcc_cv_tool_dirs
10036 do
10037   IFS=$as_save_IFS
10038   test -z "$as_dir" && as_dir=.
10039   for ac_exec_ext in '' $ac_executable_extensions; do
10040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10041     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10043     break 2
10044   fi
10045 done
10046 done
10047
10048   ;;
10049 esac
10050 fi
10051 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10052
10053 if test -n "$DLLTOOL_FOR_TARGET"; then
10054   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10055 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10056 else
10057   echo "$as_me:$LINENO: result: no" >&5
10058 echo "${ECHO_T}no" >&6
10059 fi
10060
10061 fi
10062 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10063
10064
10065 if test -n "$DLLTOOL_FOR_TARGET"; then
10066   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10067 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10068   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10069 fi
10070
10071 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10072   for ncn_progname in dlltool; do
10073     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10074 set dummy ${ncn_progname}; ac_word=$2
10075 echo "$as_me:$LINENO: checking for $ac_word" >&5
10076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10077 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10078   echo $ECHO_N "(cached) $ECHO_C" >&6
10079 else
10080   if test -n "$DLLTOOL_FOR_TARGET"; then
10081   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10082 else
10083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10084 for as_dir in $PATH
10085 do
10086   IFS=$as_save_IFS
10087   test -z "$as_dir" && as_dir=.
10088   for ac_exec_ext in '' $ac_executable_extensions; do
10089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10090     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10092     break 2
10093   fi
10094 done
10095 done
10096
10097 fi
10098 fi
10099 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10100 if test -n "$DLLTOOL_FOR_TARGET"; then
10101   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10102 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10103 else
10104   echo "$as_me:$LINENO: result: no" >&5
10105 echo "${ECHO_T}no" >&6
10106 fi
10107
10108   done
10109 fi
10110
10111 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10112   for ncn_progname in dlltool; do
10113     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10114 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10115     if test -x $with_build_time_tools/${ncn_progname}; then
10116       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10117       echo "$as_me:$LINENO: result: yes" >&5
10118 echo "${ECHO_T}yes" >&6
10119       break
10120     else
10121       echo "$as_me:$LINENO: result: no" >&5
10122 echo "${ECHO_T}no" >&6
10123     fi
10124   done
10125 fi
10126
10127 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10128   for ncn_progname in dlltool; do
10129     if test -n "$ncn_target_tool_prefix"; then
10130       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10131 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10132 echo "$as_me:$LINENO: checking for $ac_word" >&5
10133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10134 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10135   echo $ECHO_N "(cached) $ECHO_C" >&6
10136 else
10137   if test -n "$DLLTOOL_FOR_TARGET"; then
10138   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10139 else
10140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10141 for as_dir in $PATH
10142 do
10143   IFS=$as_save_IFS
10144   test -z "$as_dir" && as_dir=.
10145   for ac_exec_ext in '' $ac_executable_extensions; do
10146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10147     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10149     break 2
10150   fi
10151 done
10152 done
10153
10154 fi
10155 fi
10156 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10157 if test -n "$DLLTOOL_FOR_TARGET"; then
10158   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10159 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10160 else
10161   echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163 fi
10164
10165     fi
10166     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10167       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10168 set dummy ${ncn_progname}; ac_word=$2
10169 echo "$as_me:$LINENO: checking for $ac_word" >&5
10170 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10171 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10172   echo $ECHO_N "(cached) $ECHO_C" >&6
10173 else
10174   if test -n "$DLLTOOL_FOR_TARGET"; then
10175   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10176 else
10177 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10178 for as_dir in $PATH
10179 do
10180   IFS=$as_save_IFS
10181   test -z "$as_dir" && as_dir=.
10182   for ac_exec_ext in '' $ac_executable_extensions; do
10183   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10184     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10185     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10186     break 2
10187   fi
10188 done
10189 done
10190
10191 fi
10192 fi
10193 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10194 if test -n "$DLLTOOL_FOR_TARGET"; then
10195   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10196 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10197 else
10198   echo "$as_me:$LINENO: result: no" >&5
10199 echo "${ECHO_T}no" >&6
10200 fi
10201
10202     fi
10203     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10204   done
10205 fi
10206
10207 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10208   set dummy dlltool
10209   if test $build = $target ; then
10210     DLLTOOL_FOR_TARGET="$2"
10211   else
10212     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10213   fi
10214 else
10215   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10216 fi
10217
10218 else
10219   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10220 fi
10221
10222
10223
10224
10225 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10226   if test -n "$with_build_time_tools"; then
10227     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10228 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10229     if test -x $with_build_time_tools/ld; then
10230       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10231       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10232       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10233 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10234     else
10235       echo "$as_me:$LINENO: result: no" >&5
10236 echo "${ECHO_T}no" >&6
10237     fi
10238   elif test $build != $host && test $have_gcc_for_target = yes; then
10239     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10240     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10241     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10242   fi
10243 fi
10244 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10245   # Extract the first word of "ld", so it can be a program name with args.
10246 set dummy ld; ac_word=$2
10247 echo "$as_me:$LINENO: checking for $ac_word" >&5
10248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10249 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10250   echo $ECHO_N "(cached) $ECHO_C" >&6
10251 else
10252   case $LD_FOR_TARGET in
10253   [\\/]* | ?:[\\/]*)
10254   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10255   ;;
10256   *)
10257   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10258 for as_dir in $gcc_cv_tool_dirs
10259 do
10260   IFS=$as_save_IFS
10261   test -z "$as_dir" && as_dir=.
10262   for ac_exec_ext in '' $ac_executable_extensions; do
10263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10264     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10266     break 2
10267   fi
10268 done
10269 done
10270
10271   ;;
10272 esac
10273 fi
10274 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10275
10276 if test -n "$LD_FOR_TARGET"; then
10277   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10278 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10279 else
10280   echo "$as_me:$LINENO: result: no" >&5
10281 echo "${ECHO_T}no" >&6
10282 fi
10283
10284 fi
10285 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10286
10287
10288 if test -n "$LD_FOR_TARGET"; then
10289   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10290 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10291   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10292 fi
10293
10294 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10295   for ncn_progname in ld; do
10296     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10297 set dummy ${ncn_progname}; ac_word=$2
10298 echo "$as_me:$LINENO: checking for $ac_word" >&5
10299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10300 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10301   echo $ECHO_N "(cached) $ECHO_C" >&6
10302 else
10303   if test -n "$LD_FOR_TARGET"; then
10304   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10305 else
10306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10307 for as_dir in $PATH
10308 do
10309   IFS=$as_save_IFS
10310   test -z "$as_dir" && as_dir=.
10311   for ac_exec_ext in '' $ac_executable_extensions; do
10312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10313     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10315     break 2
10316   fi
10317 done
10318 done
10319
10320 fi
10321 fi
10322 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10323 if test -n "$LD_FOR_TARGET"; then
10324   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10325 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10326 else
10327   echo "$as_me:$LINENO: result: no" >&5
10328 echo "${ECHO_T}no" >&6
10329 fi
10330
10331   done
10332 fi
10333
10334 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10335   for ncn_progname in ld; do
10336     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10337 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10338     if test -x $with_build_time_tools/${ncn_progname}; then
10339       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10340       echo "$as_me:$LINENO: result: yes" >&5
10341 echo "${ECHO_T}yes" >&6
10342       break
10343     else
10344       echo "$as_me:$LINENO: result: no" >&5
10345 echo "${ECHO_T}no" >&6
10346     fi
10347   done
10348 fi
10349
10350 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10351   for ncn_progname in ld; do
10352     if test -n "$ncn_target_tool_prefix"; then
10353       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10354 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10355 echo "$as_me:$LINENO: checking for $ac_word" >&5
10356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10357 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10358   echo $ECHO_N "(cached) $ECHO_C" >&6
10359 else
10360   if test -n "$LD_FOR_TARGET"; then
10361   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10362 else
10363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10364 for as_dir in $PATH
10365 do
10366   IFS=$as_save_IFS
10367   test -z "$as_dir" && as_dir=.
10368   for ac_exec_ext in '' $ac_executable_extensions; do
10369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10370     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10372     break 2
10373   fi
10374 done
10375 done
10376
10377 fi
10378 fi
10379 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10380 if test -n "$LD_FOR_TARGET"; then
10381   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10382 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10383 else
10384   echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386 fi
10387
10388     fi
10389     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10390       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10391 set dummy ${ncn_progname}; ac_word=$2
10392 echo "$as_me:$LINENO: checking for $ac_word" >&5
10393 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10394 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10395   echo $ECHO_N "(cached) $ECHO_C" >&6
10396 else
10397   if test -n "$LD_FOR_TARGET"; then
10398   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10399 else
10400 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10401 for as_dir in $PATH
10402 do
10403   IFS=$as_save_IFS
10404   test -z "$as_dir" && as_dir=.
10405   for ac_exec_ext in '' $ac_executable_extensions; do
10406   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10407     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10408     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10409     break 2
10410   fi
10411 done
10412 done
10413
10414 fi
10415 fi
10416 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10417 if test -n "$LD_FOR_TARGET"; then
10418   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10419 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10420 else
10421   echo "$as_me:$LINENO: result: no" >&5
10422 echo "${ECHO_T}no" >&6
10423 fi
10424
10425     fi
10426     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10427   done
10428 fi
10429
10430 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10431   set dummy ld
10432   if test $build = $target ; then
10433     LD_FOR_TARGET="$2"
10434   else
10435     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10436   fi
10437 else
10438   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10439 fi
10440
10441 else
10442   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10443 fi
10444
10445
10446
10447
10448 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10449   if test -n "$with_build_time_tools"; then
10450     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10451 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10452     if test -x $with_build_time_tools/lipo; then
10453       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10454       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10455       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10456 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10457     else
10458       echo "$as_me:$LINENO: result: no" >&5
10459 echo "${ECHO_T}no" >&6
10460     fi
10461   elif test $build != $host && test $have_gcc_for_target = yes; then
10462     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10463     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10464     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10465   fi
10466 fi
10467 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10468   # Extract the first word of "lipo", so it can be a program name with args.
10469 set dummy lipo; ac_word=$2
10470 echo "$as_me:$LINENO: checking for $ac_word" >&5
10471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10472 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10473   echo $ECHO_N "(cached) $ECHO_C" >&6
10474 else
10475   case $LIPO_FOR_TARGET in
10476   [\\/]* | ?:[\\/]*)
10477   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10478   ;;
10479   *)
10480   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10481 for as_dir in $gcc_cv_tool_dirs
10482 do
10483   IFS=$as_save_IFS
10484   test -z "$as_dir" && as_dir=.
10485   for ac_exec_ext in '' $ac_executable_extensions; do
10486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10487     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10489     break 2
10490   fi
10491 done
10492 done
10493
10494   ;;
10495 esac
10496 fi
10497 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10498
10499 if test -n "$LIPO_FOR_TARGET"; then
10500   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10501 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10502 else
10503   echo "$as_me:$LINENO: result: no" >&5
10504 echo "${ECHO_T}no" >&6
10505 fi
10506
10507 fi
10508 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10509
10510
10511 if test -n "$LIPO_FOR_TARGET"; then
10512   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10513 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10514   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10515 fi
10516
10517 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10518   for ncn_progname in lipo; do
10519     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10520 set dummy ${ncn_progname}; ac_word=$2
10521 echo "$as_me:$LINENO: checking for $ac_word" >&5
10522 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10523 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10524   echo $ECHO_N "(cached) $ECHO_C" >&6
10525 else
10526   if test -n "$LIPO_FOR_TARGET"; then
10527   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10528 else
10529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10530 for as_dir in $PATH
10531 do
10532   IFS=$as_save_IFS
10533   test -z "$as_dir" && as_dir=.
10534   for ac_exec_ext in '' $ac_executable_extensions; do
10535   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10536     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10537     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10538     break 2
10539   fi
10540 done
10541 done
10542
10543 fi
10544 fi
10545 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10546 if test -n "$LIPO_FOR_TARGET"; then
10547   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10548 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10549 else
10550   echo "$as_me:$LINENO: result: no" >&5
10551 echo "${ECHO_T}no" >&6
10552 fi
10553
10554   done
10555 fi
10556
10557 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10558   for ncn_progname in lipo; do
10559     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10560 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10561     if test -x $with_build_time_tools/${ncn_progname}; then
10562       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10563       echo "$as_me:$LINENO: result: yes" >&5
10564 echo "${ECHO_T}yes" >&6
10565       break
10566     else
10567       echo "$as_me:$LINENO: result: no" >&5
10568 echo "${ECHO_T}no" >&6
10569     fi
10570   done
10571 fi
10572
10573 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10574   for ncn_progname in lipo; do
10575     if test -n "$ncn_target_tool_prefix"; then
10576       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10577 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10578 echo "$as_me:$LINENO: checking for $ac_word" >&5
10579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10580 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10581   echo $ECHO_N "(cached) $ECHO_C" >&6
10582 else
10583   if test -n "$LIPO_FOR_TARGET"; then
10584   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10585 else
10586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10587 for as_dir in $PATH
10588 do
10589   IFS=$as_save_IFS
10590   test -z "$as_dir" && as_dir=.
10591   for ac_exec_ext in '' $ac_executable_extensions; do
10592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10593     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10595     break 2
10596   fi
10597 done
10598 done
10599
10600 fi
10601 fi
10602 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10603 if test -n "$LIPO_FOR_TARGET"; then
10604   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10605 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10606 else
10607   echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609 fi
10610
10611     fi
10612     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10613       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10614 set dummy ${ncn_progname}; ac_word=$2
10615 echo "$as_me:$LINENO: checking for $ac_word" >&5
10616 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10617 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10618   echo $ECHO_N "(cached) $ECHO_C" >&6
10619 else
10620   if test -n "$LIPO_FOR_TARGET"; then
10621   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10622 else
10623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10624 for as_dir in $PATH
10625 do
10626   IFS=$as_save_IFS
10627   test -z "$as_dir" && as_dir=.
10628   for ac_exec_ext in '' $ac_executable_extensions; do
10629   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10630     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10631     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10632     break 2
10633   fi
10634 done
10635 done
10636
10637 fi
10638 fi
10639 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10640 if test -n "$LIPO_FOR_TARGET"; then
10641   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10642 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10643 else
10644   echo "$as_me:$LINENO: result: no" >&5
10645 echo "${ECHO_T}no" >&6
10646 fi
10647
10648     fi
10649     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10650   done
10651 fi
10652
10653 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10654   set dummy lipo
10655   if test $build = $target ; then
10656     LIPO_FOR_TARGET="$2"
10657   else
10658     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10659   fi
10660 else
10661   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10662 fi
10663
10664 else
10665   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10666 fi
10667
10668
10669
10670
10671 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10672   if test -n "$with_build_time_tools"; then
10673     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10674 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10675     if test -x $with_build_time_tools/nm; then
10676       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10677       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10678       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10679 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10680     else
10681       echo "$as_me:$LINENO: result: no" >&5
10682 echo "${ECHO_T}no" >&6
10683     fi
10684   elif test $build != $host && test $have_gcc_for_target = yes; then
10685     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10686     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10687     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10688   fi
10689 fi
10690 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10691   # Extract the first word of "nm", so it can be a program name with args.
10692 set dummy nm; ac_word=$2
10693 echo "$as_me:$LINENO: checking for $ac_word" >&5
10694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10695 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10696   echo $ECHO_N "(cached) $ECHO_C" >&6
10697 else
10698   case $NM_FOR_TARGET in
10699   [\\/]* | ?:[\\/]*)
10700   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10701   ;;
10702   *)
10703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10704 for as_dir in $gcc_cv_tool_dirs
10705 do
10706   IFS=$as_save_IFS
10707   test -z "$as_dir" && as_dir=.
10708   for ac_exec_ext in '' $ac_executable_extensions; do
10709   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10710     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10711     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10712     break 2
10713   fi
10714 done
10715 done
10716
10717   ;;
10718 esac
10719 fi
10720 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10721
10722 if test -n "$NM_FOR_TARGET"; then
10723   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10724 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10725 else
10726   echo "$as_me:$LINENO: result: no" >&5
10727 echo "${ECHO_T}no" >&6
10728 fi
10729
10730 fi
10731 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10732
10733
10734 if test -n "$NM_FOR_TARGET"; then
10735   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10736 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10737   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10738 fi
10739
10740 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10741   for ncn_progname in nm; do
10742     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10743 set dummy ${ncn_progname}; ac_word=$2
10744 echo "$as_me:$LINENO: checking for $ac_word" >&5
10745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10746 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10747   echo $ECHO_N "(cached) $ECHO_C" >&6
10748 else
10749   if test -n "$NM_FOR_TARGET"; then
10750   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10751 else
10752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10753 for as_dir in $PATH
10754 do
10755   IFS=$as_save_IFS
10756   test -z "$as_dir" && as_dir=.
10757   for ac_exec_ext in '' $ac_executable_extensions; do
10758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10759     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10761     break 2
10762   fi
10763 done
10764 done
10765
10766 fi
10767 fi
10768 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10769 if test -n "$NM_FOR_TARGET"; then
10770   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10771 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10772 else
10773   echo "$as_me:$LINENO: result: no" >&5
10774 echo "${ECHO_T}no" >&6
10775 fi
10776
10777   done
10778 fi
10779
10780 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10781   for ncn_progname in nm; do
10782     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10783 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10784     if test -x $with_build_time_tools/${ncn_progname}; then
10785       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10786       echo "$as_me:$LINENO: result: yes" >&5
10787 echo "${ECHO_T}yes" >&6
10788       break
10789     else
10790       echo "$as_me:$LINENO: result: no" >&5
10791 echo "${ECHO_T}no" >&6
10792     fi
10793   done
10794 fi
10795
10796 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10797   for ncn_progname in nm; do
10798     if test -n "$ncn_target_tool_prefix"; then
10799       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10800 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10801 echo "$as_me:$LINENO: checking for $ac_word" >&5
10802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10803 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10804   echo $ECHO_N "(cached) $ECHO_C" >&6
10805 else
10806   if test -n "$NM_FOR_TARGET"; then
10807   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10808 else
10809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10810 for as_dir in $PATH
10811 do
10812   IFS=$as_save_IFS
10813   test -z "$as_dir" && as_dir=.
10814   for ac_exec_ext in '' $ac_executable_extensions; do
10815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10816     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10818     break 2
10819   fi
10820 done
10821 done
10822
10823 fi
10824 fi
10825 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10826 if test -n "$NM_FOR_TARGET"; then
10827   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10828 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10829 else
10830   echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832 fi
10833
10834     fi
10835     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10836       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10837 set dummy ${ncn_progname}; ac_word=$2
10838 echo "$as_me:$LINENO: checking for $ac_word" >&5
10839 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10840 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10841   echo $ECHO_N "(cached) $ECHO_C" >&6
10842 else
10843   if test -n "$NM_FOR_TARGET"; then
10844   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10845 else
10846 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10847 for as_dir in $PATH
10848 do
10849   IFS=$as_save_IFS
10850   test -z "$as_dir" && as_dir=.
10851   for ac_exec_ext in '' $ac_executable_extensions; do
10852   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10853     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10854     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10855     break 2
10856   fi
10857 done
10858 done
10859
10860 fi
10861 fi
10862 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10863 if test -n "$NM_FOR_TARGET"; then
10864   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10865 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10866 else
10867   echo "$as_me:$LINENO: result: no" >&5
10868 echo "${ECHO_T}no" >&6
10869 fi
10870
10871     fi
10872     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10873   done
10874 fi
10875
10876 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10877   set dummy nm
10878   if test $build = $target ; then
10879     NM_FOR_TARGET="$2"
10880   else
10881     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10882   fi
10883 else
10884   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10885 fi
10886
10887 else
10888   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10889 fi
10890
10891
10892
10893
10894 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10895   if test -n "$with_build_time_tools"; then
10896     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10897 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10898     if test -x $with_build_time_tools/objdump; then
10899       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10900       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10901       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10902 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10903     else
10904       echo "$as_me:$LINENO: result: no" >&5
10905 echo "${ECHO_T}no" >&6
10906     fi
10907   elif test $build != $host && test $have_gcc_for_target = yes; then
10908     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10909     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10910     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10911   fi
10912 fi
10913 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10914   # Extract the first word of "objdump", so it can be a program name with args.
10915 set dummy objdump; ac_word=$2
10916 echo "$as_me:$LINENO: checking for $ac_word" >&5
10917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10918 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10919   echo $ECHO_N "(cached) $ECHO_C" >&6
10920 else
10921   case $OBJDUMP_FOR_TARGET in
10922   [\\/]* | ?:[\\/]*)
10923   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10924   ;;
10925   *)
10926   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10927 for as_dir in $gcc_cv_tool_dirs
10928 do
10929   IFS=$as_save_IFS
10930   test -z "$as_dir" && as_dir=.
10931   for ac_exec_ext in '' $ac_executable_extensions; do
10932   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10933     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10934     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10935     break 2
10936   fi
10937 done
10938 done
10939
10940   ;;
10941 esac
10942 fi
10943 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10944
10945 if test -n "$OBJDUMP_FOR_TARGET"; then
10946   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10947 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10948 else
10949   echo "$as_me:$LINENO: result: no" >&5
10950 echo "${ECHO_T}no" >&6
10951 fi
10952
10953 fi
10954 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10955
10956
10957 if test -n "$OBJDUMP_FOR_TARGET"; then
10958   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10959 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10960   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10961 fi
10962
10963 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10964   for ncn_progname in objdump; do
10965     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10966 set dummy ${ncn_progname}; ac_word=$2
10967 echo "$as_me:$LINENO: checking for $ac_word" >&5
10968 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10969 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10970   echo $ECHO_N "(cached) $ECHO_C" >&6
10971 else
10972   if test -n "$OBJDUMP_FOR_TARGET"; then
10973   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10974 else
10975 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10976 for as_dir in $PATH
10977 do
10978   IFS=$as_save_IFS
10979   test -z "$as_dir" && as_dir=.
10980   for ac_exec_ext in '' $ac_executable_extensions; do
10981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10982     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10984     break 2
10985   fi
10986 done
10987 done
10988
10989 fi
10990 fi
10991 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10992 if test -n "$OBJDUMP_FOR_TARGET"; then
10993   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10994 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10995 else
10996   echo "$as_me:$LINENO: result: no" >&5
10997 echo "${ECHO_T}no" >&6
10998 fi
10999
11000   done
11001 fi
11002
11003 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11004   for ncn_progname in objdump; do
11005     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11006 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11007     if test -x $with_build_time_tools/${ncn_progname}; then
11008       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11009       echo "$as_me:$LINENO: result: yes" >&5
11010 echo "${ECHO_T}yes" >&6
11011       break
11012     else
11013       echo "$as_me:$LINENO: result: no" >&5
11014 echo "${ECHO_T}no" >&6
11015     fi
11016   done
11017 fi
11018
11019 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
11020   for ncn_progname in objdump; do
11021     if test -n "$ncn_target_tool_prefix"; then
11022       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11023 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11024 echo "$as_me:$LINENO: checking for $ac_word" >&5
11025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11026 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11027   echo $ECHO_N "(cached) $ECHO_C" >&6
11028 else
11029   if test -n "$OBJDUMP_FOR_TARGET"; then
11030   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11031 else
11032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11033 for as_dir in $PATH
11034 do
11035   IFS=$as_save_IFS
11036   test -z "$as_dir" && as_dir=.
11037   for ac_exec_ext in '' $ac_executable_extensions; do
11038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11039     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11041     break 2
11042   fi
11043 done
11044 done
11045
11046 fi
11047 fi
11048 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11049 if test -n "$OBJDUMP_FOR_TARGET"; then
11050   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11051 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11052 else
11053   echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055 fi
11056
11057     fi
11058     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
11059       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11060 set dummy ${ncn_progname}; ac_word=$2
11061 echo "$as_me:$LINENO: checking for $ac_word" >&5
11062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11063 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11064   echo $ECHO_N "(cached) $ECHO_C" >&6
11065 else
11066   if test -n "$OBJDUMP_FOR_TARGET"; then
11067   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11068 else
11069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11070 for as_dir in $PATH
11071 do
11072   IFS=$as_save_IFS
11073   test -z "$as_dir" && as_dir=.
11074   for ac_exec_ext in '' $ac_executable_extensions; do
11075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11076     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
11077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11078     break 2
11079   fi
11080 done
11081 done
11082
11083 fi
11084 fi
11085 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11086 if test -n "$OBJDUMP_FOR_TARGET"; then
11087   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11088 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11089 else
11090   echo "$as_me:$LINENO: result: no" >&5
11091 echo "${ECHO_T}no" >&6
11092 fi
11093
11094     fi
11095     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11096   done
11097 fi
11098
11099 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11100   set dummy objdump
11101   if test $build = $target ; then
11102     OBJDUMP_FOR_TARGET="$2"
11103   else
11104     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11105   fi
11106 else
11107   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11108 fi
11109
11110 else
11111   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11112 fi
11113
11114
11115
11116
11117 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11118   if test -n "$with_build_time_tools"; then
11119     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11120 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11121     if test -x $with_build_time_tools/ranlib; then
11122       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11123       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11124       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11125 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11126     else
11127       echo "$as_me:$LINENO: result: no" >&5
11128 echo "${ECHO_T}no" >&6
11129     fi
11130   elif test $build != $host && test $have_gcc_for_target = yes; then
11131     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11132     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11133     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11134   fi
11135 fi
11136 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11137   # Extract the first word of "ranlib", so it can be a program name with args.
11138 set dummy ranlib; ac_word=$2
11139 echo "$as_me:$LINENO: checking for $ac_word" >&5
11140 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11141 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11142   echo $ECHO_N "(cached) $ECHO_C" >&6
11143 else
11144   case $RANLIB_FOR_TARGET in
11145   [\\/]* | ?:[\\/]*)
11146   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11147   ;;
11148   *)
11149   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11150 for as_dir in $gcc_cv_tool_dirs
11151 do
11152   IFS=$as_save_IFS
11153   test -z "$as_dir" && as_dir=.
11154   for ac_exec_ext in '' $ac_executable_extensions; do
11155   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11156     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11157     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11158     break 2
11159   fi
11160 done
11161 done
11162
11163   ;;
11164 esac
11165 fi
11166 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11167
11168 if test -n "$RANLIB_FOR_TARGET"; then
11169   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11170 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11171 else
11172   echo "$as_me:$LINENO: result: no" >&5
11173 echo "${ECHO_T}no" >&6
11174 fi
11175
11176 fi
11177 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11178
11179
11180 if test -n "$RANLIB_FOR_TARGET"; then
11181   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11182 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11183   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11184 fi
11185
11186 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11187   for ncn_progname in ranlib; do
11188     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11189 set dummy ${ncn_progname}; ac_word=$2
11190 echo "$as_me:$LINENO: checking for $ac_word" >&5
11191 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11192 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11193   echo $ECHO_N "(cached) $ECHO_C" >&6
11194 else
11195   if test -n "$RANLIB_FOR_TARGET"; then
11196   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11197 else
11198 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11199 for as_dir in $PATH
11200 do
11201   IFS=$as_save_IFS
11202   test -z "$as_dir" && as_dir=.
11203   for ac_exec_ext in '' $ac_executable_extensions; do
11204   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11205     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11206     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11207     break 2
11208   fi
11209 done
11210 done
11211
11212 fi
11213 fi
11214 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11215 if test -n "$RANLIB_FOR_TARGET"; then
11216   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11217 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11218 else
11219   echo "$as_me:$LINENO: result: no" >&5
11220 echo "${ECHO_T}no" >&6
11221 fi
11222
11223   done
11224 fi
11225
11226 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11227   for ncn_progname in ranlib; do
11228     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11229 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11230     if test -x $with_build_time_tools/${ncn_progname}; then
11231       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11232       echo "$as_me:$LINENO: result: yes" >&5
11233 echo "${ECHO_T}yes" >&6
11234       break
11235     else
11236       echo "$as_me:$LINENO: result: no" >&5
11237 echo "${ECHO_T}no" >&6
11238     fi
11239   done
11240 fi
11241
11242 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11243   for ncn_progname in ranlib; do
11244     if test -n "$ncn_target_tool_prefix"; then
11245       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11246 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11247 echo "$as_me:$LINENO: checking for $ac_word" >&5
11248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11249 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11250   echo $ECHO_N "(cached) $ECHO_C" >&6
11251 else
11252   if test -n "$RANLIB_FOR_TARGET"; then
11253   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11254 else
11255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11256 for as_dir in $PATH
11257 do
11258   IFS=$as_save_IFS
11259   test -z "$as_dir" && as_dir=.
11260   for ac_exec_ext in '' $ac_executable_extensions; do
11261   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11262     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11263     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11264     break 2
11265   fi
11266 done
11267 done
11268
11269 fi
11270 fi
11271 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11272 if test -n "$RANLIB_FOR_TARGET"; then
11273   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11274 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11275 else
11276   echo "$as_me:$LINENO: result: no" >&5
11277 echo "${ECHO_T}no" >&6
11278 fi
11279
11280     fi
11281     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11282       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11283 set dummy ${ncn_progname}; ac_word=$2
11284 echo "$as_me:$LINENO: checking for $ac_word" >&5
11285 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11286 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11287   echo $ECHO_N "(cached) $ECHO_C" >&6
11288 else
11289   if test -n "$RANLIB_FOR_TARGET"; then
11290   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11291 else
11292 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11293 for as_dir in $PATH
11294 do
11295   IFS=$as_save_IFS
11296   test -z "$as_dir" && as_dir=.
11297   for ac_exec_ext in '' $ac_executable_extensions; do
11298   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11299     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11300     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11301     break 2
11302   fi
11303 done
11304 done
11305
11306 fi
11307 fi
11308 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11309 if test -n "$RANLIB_FOR_TARGET"; then
11310   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11311 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11312 else
11313   echo "$as_me:$LINENO: result: no" >&5
11314 echo "${ECHO_T}no" >&6
11315 fi
11316
11317     fi
11318     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11319   done
11320 fi
11321
11322 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11323   set dummy ranlib
11324   if test $build = $target ; then
11325     RANLIB_FOR_TARGET="$2"
11326   else
11327     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11328   fi
11329 else
11330   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11331 fi
11332
11333 else
11334   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11335 fi
11336
11337
11338
11339
11340 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11341   if test -n "$with_build_time_tools"; then
11342     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11343 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11344     if test -x $with_build_time_tools/strip; then
11345       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11346       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11347       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11348 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11349     else
11350       echo "$as_me:$LINENO: result: no" >&5
11351 echo "${ECHO_T}no" >&6
11352     fi
11353   elif test $build != $host && test $have_gcc_for_target = yes; then
11354     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11355     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11356     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11357   fi
11358 fi
11359 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11360   # Extract the first word of "strip", so it can be a program name with args.
11361 set dummy strip; ac_word=$2
11362 echo "$as_me:$LINENO: checking for $ac_word" >&5
11363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11364 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11365   echo $ECHO_N "(cached) $ECHO_C" >&6
11366 else
11367   case $STRIP_FOR_TARGET in
11368   [\\/]* | ?:[\\/]*)
11369   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11370   ;;
11371   *)
11372   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11373 for as_dir in $gcc_cv_tool_dirs
11374 do
11375   IFS=$as_save_IFS
11376   test -z "$as_dir" && as_dir=.
11377   for ac_exec_ext in '' $ac_executable_extensions; do
11378   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11379     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11380     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11381     break 2
11382   fi
11383 done
11384 done
11385
11386   ;;
11387 esac
11388 fi
11389 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11390
11391 if test -n "$STRIP_FOR_TARGET"; then
11392   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11393 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11394 else
11395   echo "$as_me:$LINENO: result: no" >&5
11396 echo "${ECHO_T}no" >&6
11397 fi
11398
11399 fi
11400 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11401
11402
11403 if test -n "$STRIP_FOR_TARGET"; then
11404   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11405 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11406   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11407 fi
11408
11409 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11410   for ncn_progname in strip; do
11411     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11412 set dummy ${ncn_progname}; ac_word=$2
11413 echo "$as_me:$LINENO: checking for $ac_word" >&5
11414 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11415 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11416   echo $ECHO_N "(cached) $ECHO_C" >&6
11417 else
11418   if test -n "$STRIP_FOR_TARGET"; then
11419   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11420 else
11421 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11422 for as_dir in $PATH
11423 do
11424   IFS=$as_save_IFS
11425   test -z "$as_dir" && as_dir=.
11426   for ac_exec_ext in '' $ac_executable_extensions; do
11427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11428     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11430     break 2
11431   fi
11432 done
11433 done
11434
11435 fi
11436 fi
11437 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11438 if test -n "$STRIP_FOR_TARGET"; then
11439   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11440 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11441 else
11442   echo "$as_me:$LINENO: result: no" >&5
11443 echo "${ECHO_T}no" >&6
11444 fi
11445
11446   done
11447 fi
11448
11449 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11450   for ncn_progname in strip; do
11451     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11452 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11453     if test -x $with_build_time_tools/${ncn_progname}; then
11454       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11455       echo "$as_me:$LINENO: result: yes" >&5
11456 echo "${ECHO_T}yes" >&6
11457       break
11458     else
11459       echo "$as_me:$LINENO: result: no" >&5
11460 echo "${ECHO_T}no" >&6
11461     fi
11462   done
11463 fi
11464
11465 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11466   for ncn_progname in strip; do
11467     if test -n "$ncn_target_tool_prefix"; then
11468       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11469 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11470 echo "$as_me:$LINENO: checking for $ac_word" >&5
11471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11472 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11473   echo $ECHO_N "(cached) $ECHO_C" >&6
11474 else
11475   if test -n "$STRIP_FOR_TARGET"; then
11476   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11477 else
11478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11479 for as_dir in $PATH
11480 do
11481   IFS=$as_save_IFS
11482   test -z "$as_dir" && as_dir=.
11483   for ac_exec_ext in '' $ac_executable_extensions; do
11484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11485     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11487     break 2
11488   fi
11489 done
11490 done
11491
11492 fi
11493 fi
11494 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11495 if test -n "$STRIP_FOR_TARGET"; then
11496   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11497 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11498 else
11499   echo "$as_me:$LINENO: result: no" >&5
11500 echo "${ECHO_T}no" >&6
11501 fi
11502
11503     fi
11504     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11505       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11506 set dummy ${ncn_progname}; ac_word=$2
11507 echo "$as_me:$LINENO: checking for $ac_word" >&5
11508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11509 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11510   echo $ECHO_N "(cached) $ECHO_C" >&6
11511 else
11512   if test -n "$STRIP_FOR_TARGET"; then
11513   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11514 else
11515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11516 for as_dir in $PATH
11517 do
11518   IFS=$as_save_IFS
11519   test -z "$as_dir" && as_dir=.
11520   for ac_exec_ext in '' $ac_executable_extensions; do
11521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11522     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11524     break 2
11525   fi
11526 done
11527 done
11528
11529 fi
11530 fi
11531 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11532 if test -n "$STRIP_FOR_TARGET"; then
11533   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11534 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11535 else
11536   echo "$as_me:$LINENO: result: no" >&5
11537 echo "${ECHO_T}no" >&6
11538 fi
11539
11540     fi
11541     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11542   done
11543 fi
11544
11545 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11546   set dummy strip
11547   if test $build = $target ; then
11548     STRIP_FOR_TARGET="$2"
11549   else
11550     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11551   fi
11552 else
11553   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11554 fi
11555
11556 else
11557   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11558 fi
11559
11560
11561
11562
11563 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11564   if test -n "$with_build_time_tools"; then
11565     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11566 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11567     if test -x $with_build_time_tools/windres; then
11568       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11569       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11570       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11571 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11572     else
11573       echo "$as_me:$LINENO: result: no" >&5
11574 echo "${ECHO_T}no" >&6
11575     fi
11576   elif test $build != $host && test $have_gcc_for_target = yes; then
11577     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11578     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11579     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11580   fi
11581 fi
11582 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11583   # Extract the first word of "windres", so it can be a program name with args.
11584 set dummy windres; ac_word=$2
11585 echo "$as_me:$LINENO: checking for $ac_word" >&5
11586 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11587 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11588   echo $ECHO_N "(cached) $ECHO_C" >&6
11589 else
11590   case $WINDRES_FOR_TARGET in
11591   [\\/]* | ?:[\\/]*)
11592   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11593   ;;
11594   *)
11595   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11596 for as_dir in $gcc_cv_tool_dirs
11597 do
11598   IFS=$as_save_IFS
11599   test -z "$as_dir" && as_dir=.
11600   for ac_exec_ext in '' $ac_executable_extensions; do
11601   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11602     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11603     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11604     break 2
11605   fi
11606 done
11607 done
11608
11609   ;;
11610 esac
11611 fi
11612 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11613
11614 if test -n "$WINDRES_FOR_TARGET"; then
11615   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11616 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11617 else
11618   echo "$as_me:$LINENO: result: no" >&5
11619 echo "${ECHO_T}no" >&6
11620 fi
11621
11622 fi
11623 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11624
11625
11626 if test -n "$WINDRES_FOR_TARGET"; then
11627   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11628 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11629   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11630 fi
11631
11632 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11633   for ncn_progname in windres; do
11634     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11635 set dummy ${ncn_progname}; ac_word=$2
11636 echo "$as_me:$LINENO: checking for $ac_word" >&5
11637 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11638 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11639   echo $ECHO_N "(cached) $ECHO_C" >&6
11640 else
11641   if test -n "$WINDRES_FOR_TARGET"; then
11642   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11643 else
11644 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11645 for as_dir in $PATH
11646 do
11647   IFS=$as_save_IFS
11648   test -z "$as_dir" && as_dir=.
11649   for ac_exec_ext in '' $ac_executable_extensions; do
11650   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11651     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11652     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11653     break 2
11654   fi
11655 done
11656 done
11657
11658 fi
11659 fi
11660 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11661 if test -n "$WINDRES_FOR_TARGET"; then
11662   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11663 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11664 else
11665   echo "$as_me:$LINENO: result: no" >&5
11666 echo "${ECHO_T}no" >&6
11667 fi
11668
11669   done
11670 fi
11671
11672 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11673   for ncn_progname in windres; do
11674     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11675 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11676     if test -x $with_build_time_tools/${ncn_progname}; then
11677       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11678       echo "$as_me:$LINENO: result: yes" >&5
11679 echo "${ECHO_T}yes" >&6
11680       break
11681     else
11682       echo "$as_me:$LINENO: result: no" >&5
11683 echo "${ECHO_T}no" >&6
11684     fi
11685   done
11686 fi
11687
11688 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11689   for ncn_progname in windres; do
11690     if test -n "$ncn_target_tool_prefix"; then
11691       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11692 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11693 echo "$as_me:$LINENO: checking for $ac_word" >&5
11694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11695 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11696   echo $ECHO_N "(cached) $ECHO_C" >&6
11697 else
11698   if test -n "$WINDRES_FOR_TARGET"; then
11699   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11700 else
11701 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11702 for as_dir in $PATH
11703 do
11704   IFS=$as_save_IFS
11705   test -z "$as_dir" && as_dir=.
11706   for ac_exec_ext in '' $ac_executable_extensions; do
11707   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11708     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11709     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11710     break 2
11711   fi
11712 done
11713 done
11714
11715 fi
11716 fi
11717 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11718 if test -n "$WINDRES_FOR_TARGET"; then
11719   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11720 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11721 else
11722   echo "$as_me:$LINENO: result: no" >&5
11723 echo "${ECHO_T}no" >&6
11724 fi
11725
11726     fi
11727     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11728       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11729 set dummy ${ncn_progname}; ac_word=$2
11730 echo "$as_me:$LINENO: checking for $ac_word" >&5
11731 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11732 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11733   echo $ECHO_N "(cached) $ECHO_C" >&6
11734 else
11735   if test -n "$WINDRES_FOR_TARGET"; then
11736   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11737 else
11738 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11739 for as_dir in $PATH
11740 do
11741   IFS=$as_save_IFS
11742   test -z "$as_dir" && as_dir=.
11743   for ac_exec_ext in '' $ac_executable_extensions; do
11744   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11745     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11746     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11747     break 2
11748   fi
11749 done
11750 done
11751
11752 fi
11753 fi
11754 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11755 if test -n "$WINDRES_FOR_TARGET"; then
11756   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11757 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11758 else
11759   echo "$as_me:$LINENO: result: no" >&5
11760 echo "${ECHO_T}no" >&6
11761 fi
11762
11763     fi
11764     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11765   done
11766 fi
11767
11768 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11769   set dummy windres
11770   if test $build = $target ; then
11771     WINDRES_FOR_TARGET="$2"
11772   else
11773     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11774   fi
11775 else
11776   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11777 fi
11778
11779 else
11780   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11781 fi
11782
11783
11784
11785
11786 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11787   if test -n "$with_build_time_tools"; then
11788     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11789 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11790     if test -x $with_build_time_tools/windmc; then
11791       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11792       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11793       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11794 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11795     else
11796       echo "$as_me:$LINENO: result: no" >&5
11797 echo "${ECHO_T}no" >&6
11798     fi
11799   elif test $build != $host && test $have_gcc_for_target = yes; then
11800     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11801     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11802     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11803   fi
11804 fi
11805 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11806   # Extract the first word of "windmc", so it can be a program name with args.
11807 set dummy windmc; ac_word=$2
11808 echo "$as_me:$LINENO: checking for $ac_word" >&5
11809 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11810 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11811   echo $ECHO_N "(cached) $ECHO_C" >&6
11812 else
11813   case $WINDMC_FOR_TARGET in
11814   [\\/]* | ?:[\\/]*)
11815   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11816   ;;
11817   *)
11818   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11819 for as_dir in $gcc_cv_tool_dirs
11820 do
11821   IFS=$as_save_IFS
11822   test -z "$as_dir" && as_dir=.
11823   for ac_exec_ext in '' $ac_executable_extensions; do
11824   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11825     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11826     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11827     break 2
11828   fi
11829 done
11830 done
11831
11832   ;;
11833 esac
11834 fi
11835 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11836
11837 if test -n "$WINDMC_FOR_TARGET"; then
11838   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11839 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11840 else
11841   echo "$as_me:$LINENO: result: no" >&5
11842 echo "${ECHO_T}no" >&6
11843 fi
11844
11845 fi
11846 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11847
11848
11849 if test -n "$WINDMC_FOR_TARGET"; then
11850   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11851 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11852   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11853 fi
11854
11855 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11856   for ncn_progname in windmc; do
11857     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11858 set dummy ${ncn_progname}; ac_word=$2
11859 echo "$as_me:$LINENO: checking for $ac_word" >&5
11860 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11861 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11862   echo $ECHO_N "(cached) $ECHO_C" >&6
11863 else
11864   if test -n "$WINDMC_FOR_TARGET"; then
11865   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11866 else
11867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11868 for as_dir in $PATH
11869 do
11870   IFS=$as_save_IFS
11871   test -z "$as_dir" && as_dir=.
11872   for ac_exec_ext in '' $ac_executable_extensions; do
11873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11874     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11876     break 2
11877   fi
11878 done
11879 done
11880
11881 fi
11882 fi
11883 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11884 if test -n "$WINDMC_FOR_TARGET"; then
11885   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11886 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11887 else
11888   echo "$as_me:$LINENO: result: no" >&5
11889 echo "${ECHO_T}no" >&6
11890 fi
11891
11892   done
11893 fi
11894
11895 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11896   for ncn_progname in windmc; do
11897     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11898 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11899     if test -x $with_build_time_tools/${ncn_progname}; then
11900       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11901       echo "$as_me:$LINENO: result: yes" >&5
11902 echo "${ECHO_T}yes" >&6
11903       break
11904     else
11905       echo "$as_me:$LINENO: result: no" >&5
11906 echo "${ECHO_T}no" >&6
11907     fi
11908   done
11909 fi
11910
11911 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11912   for ncn_progname in windmc; do
11913     if test -n "$ncn_target_tool_prefix"; then
11914       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11915 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11916 echo "$as_me:$LINENO: checking for $ac_word" >&5
11917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11918 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11919   echo $ECHO_N "(cached) $ECHO_C" >&6
11920 else
11921   if test -n "$WINDMC_FOR_TARGET"; then
11922   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11923 else
11924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11925 for as_dir in $PATH
11926 do
11927   IFS=$as_save_IFS
11928   test -z "$as_dir" && as_dir=.
11929   for ac_exec_ext in '' $ac_executable_extensions; do
11930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11931     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11933     break 2
11934   fi
11935 done
11936 done
11937
11938 fi
11939 fi
11940 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11941 if test -n "$WINDMC_FOR_TARGET"; then
11942   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11943 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11944 else
11945   echo "$as_me:$LINENO: result: no" >&5
11946 echo "${ECHO_T}no" >&6
11947 fi
11948
11949     fi
11950     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11951       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11952 set dummy ${ncn_progname}; ac_word=$2
11953 echo "$as_me:$LINENO: checking for $ac_word" >&5
11954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11955 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11956   echo $ECHO_N "(cached) $ECHO_C" >&6
11957 else
11958   if test -n "$WINDMC_FOR_TARGET"; then
11959   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11960 else
11961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11962 for as_dir in $PATH
11963 do
11964   IFS=$as_save_IFS
11965   test -z "$as_dir" && as_dir=.
11966   for ac_exec_ext in '' $ac_executable_extensions; do
11967   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11968     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11969     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11970     break 2
11971   fi
11972 done
11973 done
11974
11975 fi
11976 fi
11977 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11978 if test -n "$WINDMC_FOR_TARGET"; then
11979   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11980 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11981 else
11982   echo "$as_me:$LINENO: result: no" >&5
11983 echo "${ECHO_T}no" >&6
11984 fi
11985
11986     fi
11987     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11988   done
11989 fi
11990
11991 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11992   set dummy windmc
11993   if test $build = $target ; then
11994     WINDMC_FOR_TARGET="$2"
11995   else
11996     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11997   fi
11998 else
11999   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
12000 fi
12001
12002 else
12003   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
12004 fi
12005
12006
12007 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
12008
12009 echo "$as_me:$LINENO: checking where to find the target ar" >&5
12010 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
12011 if test "x${build}" != "x${host}" ; then
12012   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12013     # We already found the complete path
12014     ac_dir=`dirname $AR_FOR_TARGET`
12015     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12016 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12017   else
12018     # Canadian cross, just use what we found
12019     echo "$as_me:$LINENO: result: pre-installed" >&5
12020 echo "${ECHO_T}pre-installed" >&6
12021   fi
12022 else
12023   ok=yes
12024   case " ${configdirs} " in
12025     *" binutils "*) ;;
12026     *) ok=no ;;
12027   esac
12028
12029   if test $ok = yes; then
12030     # An in-tree tool is available and we can use it
12031     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
12032     echo "$as_me:$LINENO: result: just compiled" >&5
12033 echo "${ECHO_T}just compiled" >&6
12034   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12035     # We already found the complete path
12036     ac_dir=`dirname $AR_FOR_TARGET`
12037     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12038 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12039   elif test "x$target" = "x$host"; then
12040     # We can use an host tool
12041     AR_FOR_TARGET='$(AR)'
12042     echo "$as_me:$LINENO: result: host tool" >&5
12043 echo "${ECHO_T}host tool" >&6
12044   else
12045     # We need a cross tool
12046     echo "$as_me:$LINENO: result: pre-installed" >&5
12047 echo "${ECHO_T}pre-installed" >&6
12048   fi
12049 fi
12050
12051 echo "$as_me:$LINENO: checking where to find the target as" >&5
12052 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
12053 if test "x${build}" != "x${host}" ; then
12054   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12055     # We already found the complete path
12056     ac_dir=`dirname $AS_FOR_TARGET`
12057     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12058 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12059   else
12060     # Canadian cross, just use what we found
12061     echo "$as_me:$LINENO: result: pre-installed" >&5
12062 echo "${ECHO_T}pre-installed" >&6
12063   fi
12064 else
12065   ok=yes
12066   case " ${configdirs} " in
12067     *" gas "*) ;;
12068     *) ok=no ;;
12069   esac
12070
12071   if test $ok = yes; then
12072     # An in-tree tool is available and we can use it
12073     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
12074     echo "$as_me:$LINENO: result: just compiled" >&5
12075 echo "${ECHO_T}just compiled" >&6
12076   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12077     # We already found the complete path
12078     ac_dir=`dirname $AS_FOR_TARGET`
12079     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12080 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12081   elif test "x$target" = "x$host"; then
12082     # We can use an host tool
12083     AS_FOR_TARGET='$(AS)'
12084     echo "$as_me:$LINENO: result: host tool" >&5
12085 echo "${ECHO_T}host tool" >&6
12086   else
12087     # We need a cross tool
12088     echo "$as_me:$LINENO: result: pre-installed" >&5
12089 echo "${ECHO_T}pre-installed" >&6
12090   fi
12091 fi
12092
12093 echo "$as_me:$LINENO: checking where to find the target cc" >&5
12094 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12095 if test "x${build}" != "x${host}" ; then
12096   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12097     # We already found the complete path
12098     ac_dir=`dirname $CC_FOR_TARGET`
12099     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12100 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12101   else
12102     # Canadian cross, just use what we found
12103     echo "$as_me:$LINENO: result: pre-installed" >&5
12104 echo "${ECHO_T}pre-installed" >&6
12105   fi
12106 else
12107   ok=yes
12108   case " ${configdirs} " in
12109     *" gcc "*) ;;
12110     *) ok=no ;;
12111   esac
12112
12113   if test $ok = yes; then
12114     # An in-tree tool is available and we can use it
12115     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12116     echo "$as_me:$LINENO: result: just compiled" >&5
12117 echo "${ECHO_T}just compiled" >&6
12118   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12119     # We already found the complete path
12120     ac_dir=`dirname $CC_FOR_TARGET`
12121     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12122 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12123   elif test "x$target" = "x$host"; then
12124     # We can use an host tool
12125     CC_FOR_TARGET='$(CC)'
12126     echo "$as_me:$LINENO: result: host tool" >&5
12127 echo "${ECHO_T}host tool" >&6
12128   else
12129     # We need a cross tool
12130     echo "$as_me:$LINENO: result: pre-installed" >&5
12131 echo "${ECHO_T}pre-installed" >&6
12132   fi
12133 fi
12134
12135 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12136 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12137 if test "x${build}" != "x${host}" ; then
12138   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12139     # We already found the complete path
12140     ac_dir=`dirname $CXX_FOR_TARGET`
12141     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12142 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12143   else
12144     # Canadian cross, just use what we found
12145     echo "$as_me:$LINENO: result: pre-installed" >&5
12146 echo "${ECHO_T}pre-installed" >&6
12147   fi
12148 else
12149   ok=yes
12150   case " ${configdirs} " in
12151     *" gcc "*) ;;
12152     *) ok=no ;;
12153   esac
12154   case ,${enable_languages}, in
12155     *,c++,*) ;;
12156     *) ok=no ;;
12157   esac
12158   if test $ok = yes; then
12159     # An in-tree tool is available and we can use it
12160     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'
12161     echo "$as_me:$LINENO: result: just compiled" >&5
12162 echo "${ECHO_T}just compiled" >&6
12163   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12164     # We already found the complete path
12165     ac_dir=`dirname $CXX_FOR_TARGET`
12166     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12167 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12168   elif test "x$target" = "x$host"; then
12169     # We can use an host tool
12170     CXX_FOR_TARGET='$(CXX)'
12171     echo "$as_me:$LINENO: result: host tool" >&5
12172 echo "${ECHO_T}host tool" >&6
12173   else
12174     # We need a cross tool
12175     echo "$as_me:$LINENO: result: pre-installed" >&5
12176 echo "${ECHO_T}pre-installed" >&6
12177   fi
12178 fi
12179
12180 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12181 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12182 if test "x${build}" != "x${host}" ; then
12183   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12184     # We already found the complete path
12185     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12186     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12187 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12188   else
12189     # Canadian cross, just use what we found
12190     echo "$as_me:$LINENO: result: pre-installed" >&5
12191 echo "${ECHO_T}pre-installed" >&6
12192   fi
12193 else
12194   ok=yes
12195   case " ${configdirs} " in
12196     *" gcc "*) ;;
12197     *) ok=no ;;
12198   esac
12199   case ,${enable_languages}, in
12200     *,c++,*) ;;
12201     *) ok=no ;;
12202   esac
12203   if test $ok = yes; then
12204     # An in-tree tool is available and we can use it
12205     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'
12206     echo "$as_me:$LINENO: result: just compiled" >&5
12207 echo "${ECHO_T}just compiled" >&6
12208   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12209     # We already found the complete path
12210     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12211     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12212 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12213   elif test "x$target" = "x$host"; then
12214     # We can use an host tool
12215     RAW_CXX_FOR_TARGET='$(CXX)'
12216     echo "$as_me:$LINENO: result: host tool" >&5
12217 echo "${ECHO_T}host tool" >&6
12218   else
12219     # We need a cross tool
12220     echo "$as_me:$LINENO: result: pre-installed" >&5
12221 echo "${ECHO_T}pre-installed" >&6
12222   fi
12223 fi
12224
12225 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12226 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12227 if test "x${build}" != "x${host}" ; then
12228   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12229     # We already found the complete path
12230     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12231     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12232 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12233   else
12234     # Canadian cross, just use what we found
12235     echo "$as_me:$LINENO: result: pre-installed" >&5
12236 echo "${ECHO_T}pre-installed" >&6
12237   fi
12238 else
12239   ok=yes
12240   case " ${configdirs} " in
12241     *" binutils "*) ;;
12242     *) ok=no ;;
12243   esac
12244
12245   if test $ok = yes; then
12246     # An in-tree tool is available and we can use it
12247     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12248     echo "$as_me:$LINENO: result: just compiled" >&5
12249 echo "${ECHO_T}just compiled" >&6
12250   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12251     # We already found the complete path
12252     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12253     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12254 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12255   elif test "x$target" = "x$host"; then
12256     # We can use an host tool
12257     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12258     echo "$as_me:$LINENO: result: host tool" >&5
12259 echo "${ECHO_T}host tool" >&6
12260   else
12261     # We need a cross tool
12262     echo "$as_me:$LINENO: result: pre-installed" >&5
12263 echo "${ECHO_T}pre-installed" >&6
12264   fi
12265 fi
12266
12267 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12268 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12269 if test "x${build}" != "x${host}" ; then
12270   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12271     # We already found the complete path
12272     ac_dir=`dirname $GCC_FOR_TARGET`
12273     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12274 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12275   else
12276     # Canadian cross, just use what we found
12277     echo "$as_me:$LINENO: result: pre-installed" >&5
12278 echo "${ECHO_T}pre-installed" >&6
12279   fi
12280 else
12281   ok=yes
12282   case " ${configdirs} " in
12283     *" gcc "*) ;;
12284     *) ok=no ;;
12285   esac
12286
12287   if test $ok = yes; then
12288     # An in-tree tool is available and we can use it
12289     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12290     echo "$as_me:$LINENO: result: just compiled" >&5
12291 echo "${ECHO_T}just compiled" >&6
12292   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12293     # We already found the complete path
12294     ac_dir=`dirname $GCC_FOR_TARGET`
12295     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12296 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12297   elif test "x$target" = "x$host"; then
12298     # We can use an host tool
12299     GCC_FOR_TARGET='$()'
12300     echo "$as_me:$LINENO: result: host tool" >&5
12301 echo "${ECHO_T}host tool" >&6
12302   else
12303     # We need a cross tool
12304     echo "$as_me:$LINENO: result: pre-installed" >&5
12305 echo "${ECHO_T}pre-installed" >&6
12306   fi
12307 fi
12308
12309 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12310 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12311 if test "x${build}" != "x${host}" ; then
12312   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12313     # We already found the complete path
12314     ac_dir=`dirname $GCJ_FOR_TARGET`
12315     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12316 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12317   else
12318     # Canadian cross, just use what we found
12319     echo "$as_me:$LINENO: result: pre-installed" >&5
12320 echo "${ECHO_T}pre-installed" >&6
12321   fi
12322 else
12323   ok=yes
12324   case " ${configdirs} " in
12325     *" gcc "*) ;;
12326     *) ok=no ;;
12327   esac
12328   case ,${enable_languages}, in
12329     *,java,*) ;;
12330     *) ok=no ;;
12331   esac
12332   if test $ok = yes; then
12333     # An in-tree tool is available and we can use it
12334     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12335     echo "$as_me:$LINENO: result: just compiled" >&5
12336 echo "${ECHO_T}just compiled" >&6
12337   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12338     # We already found the complete path
12339     ac_dir=`dirname $GCJ_FOR_TARGET`
12340     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12341 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12342   elif test "x$target" = "x$host"; then
12343     # We can use an host tool
12344     GCJ_FOR_TARGET='$(GCJ)'
12345     echo "$as_me:$LINENO: result: host tool" >&5
12346 echo "${ECHO_T}host tool" >&6
12347   else
12348     # We need a cross tool
12349     echo "$as_me:$LINENO: result: pre-installed" >&5
12350 echo "${ECHO_T}pre-installed" >&6
12351   fi
12352 fi
12353
12354 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12355 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12356 if test "x${build}" != "x${host}" ; then
12357   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12358     # We already found the complete path
12359     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12360     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12361 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12362   else
12363     # Canadian cross, just use what we found
12364     echo "$as_me:$LINENO: result: pre-installed" >&5
12365 echo "${ECHO_T}pre-installed" >&6
12366   fi
12367 else
12368   ok=yes
12369   case " ${configdirs} " in
12370     *" gcc "*) ;;
12371     *) ok=no ;;
12372   esac
12373   case ,${enable_languages}, in
12374     *,fortran,*) ;;
12375     *) ok=no ;;
12376   esac
12377   if test $ok = yes; then
12378     # An in-tree tool is available and we can use it
12379     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12380     echo "$as_me:$LINENO: result: just compiled" >&5
12381 echo "${ECHO_T}just compiled" >&6
12382   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12383     # We already found the complete path
12384     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12385     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12386 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12387   elif test "x$target" = "x$host"; then
12388     # We can use an host tool
12389     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12390     echo "$as_me:$LINENO: result: host tool" >&5
12391 echo "${ECHO_T}host tool" >&6
12392   else
12393     # We need a cross tool
12394     echo "$as_me:$LINENO: result: pre-installed" >&5
12395 echo "${ECHO_T}pre-installed" >&6
12396   fi
12397 fi
12398
12399 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12400 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12401 if test "x${build}" != "x${host}" ; then
12402   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12403     # We already found the complete path
12404     ac_dir=`dirname $LD_FOR_TARGET`
12405     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12406 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12407   else
12408     # Canadian cross, just use what we found
12409     echo "$as_me:$LINENO: result: pre-installed" >&5
12410 echo "${ECHO_T}pre-installed" >&6
12411   fi
12412 else
12413   ok=yes
12414   case " ${configdirs} " in
12415     *" ld "*) ;;
12416     *) ok=no ;;
12417   esac
12418
12419   if test $ok = yes; then
12420     # An in-tree tool is available and we can use it
12421     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12422     echo "$as_me:$LINENO: result: just compiled" >&5
12423 echo "${ECHO_T}just compiled" >&6
12424   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12425     # We already found the complete path
12426     ac_dir=`dirname $LD_FOR_TARGET`
12427     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12428 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12429   elif test "x$target" = "x$host"; then
12430     # We can use an host tool
12431     LD_FOR_TARGET='$(LD)'
12432     echo "$as_me:$LINENO: result: host tool" >&5
12433 echo "${ECHO_T}host tool" >&6
12434   else
12435     # We need a cross tool
12436     echo "$as_me:$LINENO: result: pre-installed" >&5
12437 echo "${ECHO_T}pre-installed" >&6
12438   fi
12439 fi
12440
12441 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12442 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12443 if test "x${build}" != "x${host}" ; then
12444   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12445     # We already found the complete path
12446     ac_dir=`dirname $LIPO_FOR_TARGET`
12447     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12448 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12449   else
12450     # Canadian cross, just use what we found
12451     echo "$as_me:$LINENO: result: pre-installed" >&5
12452 echo "${ECHO_T}pre-installed" >&6
12453   fi
12454 else
12455   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12456     # We already found the complete path
12457     ac_dir=`dirname $LIPO_FOR_TARGET`
12458     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12459 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12460   elif test "x$target" = "x$host"; then
12461     # We can use an host tool
12462     LIPO_FOR_TARGET='$(LIPO)'
12463     echo "$as_me:$LINENO: result: host tool" >&5
12464 echo "${ECHO_T}host tool" >&6
12465   else
12466     # We need a cross tool
12467     echo "$as_me:$LINENO: result: pre-installed" >&5
12468 echo "${ECHO_T}pre-installed" >&6
12469   fi
12470 fi
12471
12472 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12473 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12474 if test "x${build}" != "x${host}" ; then
12475   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12476     # We already found the complete path
12477     ac_dir=`dirname $NM_FOR_TARGET`
12478     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12479 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12480   else
12481     # Canadian cross, just use what we found
12482     echo "$as_me:$LINENO: result: pre-installed" >&5
12483 echo "${ECHO_T}pre-installed" >&6
12484   fi
12485 else
12486   ok=yes
12487   case " ${configdirs} " in
12488     *" binutils "*) ;;
12489     *) ok=no ;;
12490   esac
12491
12492   if test $ok = yes; then
12493     # An in-tree tool is available and we can use it
12494     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12495     echo "$as_me:$LINENO: result: just compiled" >&5
12496 echo "${ECHO_T}just compiled" >&6
12497   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12498     # We already found the complete path
12499     ac_dir=`dirname $NM_FOR_TARGET`
12500     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12501 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12502   elif test "x$target" = "x$host"; then
12503     # We can use an host tool
12504     NM_FOR_TARGET='$(NM)'
12505     echo "$as_me:$LINENO: result: host tool" >&5
12506 echo "${ECHO_T}host tool" >&6
12507   else
12508     # We need a cross tool
12509     echo "$as_me:$LINENO: result: pre-installed" >&5
12510 echo "${ECHO_T}pre-installed" >&6
12511   fi
12512 fi
12513
12514 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12515 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12516 if test "x${build}" != "x${host}" ; then
12517   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12518     # We already found the complete path
12519     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12520     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12521 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12522   else
12523     # Canadian cross, just use what we found
12524     echo "$as_me:$LINENO: result: pre-installed" >&5
12525 echo "${ECHO_T}pre-installed" >&6
12526   fi
12527 else
12528   ok=yes
12529   case " ${configdirs} " in
12530     *" binutils "*) ;;
12531     *) ok=no ;;
12532   esac
12533
12534   if test $ok = yes; then
12535     # An in-tree tool is available and we can use it
12536     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12537     echo "$as_me:$LINENO: result: just compiled" >&5
12538 echo "${ECHO_T}just compiled" >&6
12539   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12540     # We already found the complete path
12541     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12542     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12543 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12544   elif test "x$target" = "x$host"; then
12545     # We can use an host tool
12546     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12547     echo "$as_me:$LINENO: result: host tool" >&5
12548 echo "${ECHO_T}host tool" >&6
12549   else
12550     # We need a cross tool
12551     echo "$as_me:$LINENO: result: pre-installed" >&5
12552 echo "${ECHO_T}pre-installed" >&6
12553   fi
12554 fi
12555
12556 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12557 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12558 if test "x${build}" != "x${host}" ; then
12559   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12560     # We already found the complete path
12561     ac_dir=`dirname $RANLIB_FOR_TARGET`
12562     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12563 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12564   else
12565     # Canadian cross, just use what we found
12566     echo "$as_me:$LINENO: result: pre-installed" >&5
12567 echo "${ECHO_T}pre-installed" >&6
12568   fi
12569 else
12570   ok=yes
12571   case " ${configdirs} " in
12572     *" binutils "*) ;;
12573     *) ok=no ;;
12574   esac
12575
12576   if test $ok = yes; then
12577     # An in-tree tool is available and we can use it
12578     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12579     echo "$as_me:$LINENO: result: just compiled" >&5
12580 echo "${ECHO_T}just compiled" >&6
12581   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12582     # We already found the complete path
12583     ac_dir=`dirname $RANLIB_FOR_TARGET`
12584     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12585 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12586   elif test "x$target" = "x$host"; then
12587     # We can use an host tool
12588     RANLIB_FOR_TARGET='$(RANLIB)'
12589     echo "$as_me:$LINENO: result: host tool" >&5
12590 echo "${ECHO_T}host tool" >&6
12591   else
12592     # We need a cross tool
12593     echo "$as_me:$LINENO: result: pre-installed" >&5
12594 echo "${ECHO_T}pre-installed" >&6
12595   fi
12596 fi
12597
12598 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12599 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12600 if test "x${build}" != "x${host}" ; then
12601   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12602     # We already found the complete path
12603     ac_dir=`dirname $STRIP_FOR_TARGET`
12604     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12605 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12606   else
12607     # Canadian cross, just use what we found
12608     echo "$as_me:$LINENO: result: pre-installed" >&5
12609 echo "${ECHO_T}pre-installed" >&6
12610   fi
12611 else
12612   ok=yes
12613   case " ${configdirs} " in
12614     *" binutils "*) ;;
12615     *) ok=no ;;
12616   esac
12617
12618   if test $ok = yes; then
12619     # An in-tree tool is available and we can use it
12620     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12621     echo "$as_me:$LINENO: result: just compiled" >&5
12622 echo "${ECHO_T}just compiled" >&6
12623   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12624     # We already found the complete path
12625     ac_dir=`dirname $STRIP_FOR_TARGET`
12626     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12627 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12628   elif test "x$target" = "x$host"; then
12629     # We can use an host tool
12630     STRIP_FOR_TARGET='$(STRIP)'
12631     echo "$as_me:$LINENO: result: host tool" >&5
12632 echo "${ECHO_T}host tool" >&6
12633   else
12634     # We need a cross tool
12635     echo "$as_me:$LINENO: result: pre-installed" >&5
12636 echo "${ECHO_T}pre-installed" >&6
12637   fi
12638 fi
12639
12640 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12641 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12642 if test "x${build}" != "x${host}" ; then
12643   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12644     # We already found the complete path
12645     ac_dir=`dirname $WINDRES_FOR_TARGET`
12646     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12647 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12648   else
12649     # Canadian cross, just use what we found
12650     echo "$as_me:$LINENO: result: pre-installed" >&5
12651 echo "${ECHO_T}pre-installed" >&6
12652   fi
12653 else
12654   ok=yes
12655   case " ${configdirs} " in
12656     *" binutils "*) ;;
12657     *) ok=no ;;
12658   esac
12659
12660   if test $ok = yes; then
12661     # An in-tree tool is available and we can use it
12662     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12663     echo "$as_me:$LINENO: result: just compiled" >&5
12664 echo "${ECHO_T}just compiled" >&6
12665   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12666     # We already found the complete path
12667     ac_dir=`dirname $WINDRES_FOR_TARGET`
12668     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12669 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12670   elif test "x$target" = "x$host"; then
12671     # We can use an host tool
12672     WINDRES_FOR_TARGET='$(WINDRES)'
12673     echo "$as_me:$LINENO: result: host tool" >&5
12674 echo "${ECHO_T}host tool" >&6
12675   else
12676     # We need a cross tool
12677     echo "$as_me:$LINENO: result: pre-installed" >&5
12678 echo "${ECHO_T}pre-installed" >&6
12679   fi
12680 fi
12681
12682 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12683 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12684 if test "x${build}" != "x${host}" ; then
12685   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12686     # We already found the complete path
12687     ac_dir=`dirname $WINDMC_FOR_TARGET`
12688     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12689 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12690   else
12691     # Canadian cross, just use what we found
12692     echo "$as_me:$LINENO: result: pre-installed" >&5
12693 echo "${ECHO_T}pre-installed" >&6
12694   fi
12695 else
12696   ok=yes
12697   case " ${configdirs} " in
12698     *" binutils "*) ;;
12699     *) ok=no ;;
12700   esac
12701
12702   if test $ok = yes; then
12703     # An in-tree tool is available and we can use it
12704     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12705     echo "$as_me:$LINENO: result: just compiled" >&5
12706 echo "${ECHO_T}just compiled" >&6
12707   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12708     # We already found the complete path
12709     ac_dir=`dirname $WINDMC_FOR_TARGET`
12710     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12711 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12712   elif test "x$target" = "x$host"; then
12713     # We can use an host tool
12714     WINDMC_FOR_TARGET='$(WINDMC)'
12715     echo "$as_me:$LINENO: result: host tool" >&5
12716 echo "${ECHO_T}host tool" >&6
12717   else
12718     # We need a cross tool
12719     echo "$as_me:$LINENO: result: pre-installed" >&5
12720 echo "${ECHO_T}pre-installed" >&6
12721   fi
12722 fi
12723
12724
12725
12726
12727
12728 # Certain tools may need extra flags.
12729 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12730 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12731 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12732
12733 # When building target libraries, except in a Canadian cross, we use
12734 # the same toolchain as the compiler we just built.
12735 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12736 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12737 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12738 if test $host = $build; then
12739   case " $configdirs " in
12740     *" gcc "*)
12741       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12742       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12743       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12744       ;;
12745   esac
12746 fi
12747
12748
12749
12750
12751
12752 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12753 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12754 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12755 if test "${enable_maintainer_mode+set}" = set; then
12756   enableval="$enable_maintainer_mode"
12757   USE_MAINTAINER_MODE=$enableval
12758 else
12759   USE_MAINTAINER_MODE=no
12760 fi;
12761 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12762 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12763
12764
12765 if test "$USE_MAINTAINER_MODE" = yes; then
12766   MAINTAINER_MODE_TRUE=
12767   MAINTAINER_MODE_FALSE='#'
12768 else
12769   MAINTAINER_MODE_TRUE='#'
12770   MAINTAINER_MODE_FALSE=
12771 fi
12772 MAINT=$MAINTAINER_MODE_TRUE
12773
12774 # ---------------------
12775 # GCC bootstrap support
12776 # ---------------------
12777
12778 # Stage specific cflags for build.
12779 stage1_cflags="-g"
12780 case $build in
12781   vax-*-*)
12782     case ${GCC} in
12783       yes) stage1_cflags="-g -Wa,-J" ;;
12784       *) stage1_cflags="-g -J" ;;
12785     esac ;;
12786 esac
12787
12788 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12789 if test "$GCC" = yes -a "$ENABLE_BUILD_WITH_CXX" != yes; then
12790   saved_CFLAGS="$CFLAGS"
12791
12792   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12793   CFLAGS="$CFLAGS -fkeep-inline-functions"
12794   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12795 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12796   cat >conftest.$ac_ext <<_ACEOF
12797 /* confdefs.h.  */
12798 _ACEOF
12799 cat confdefs.h >>conftest.$ac_ext
12800 cat >>conftest.$ac_ext <<_ACEOF
12801 /* end confdefs.h.  */
12802
12803 #if (__GNUC__ < 3) \
12804     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12805                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12806 #error http://gcc.gnu.org/PR29382
12807 #endif
12808
12809 int
12810 main ()
12811 {
12812
12813   ;
12814   return 0;
12815 }
12816 _ACEOF
12817 rm -f conftest.$ac_objext
12818 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12819   (eval $ac_compile) 2>conftest.er1
12820   ac_status=$?
12821   grep -v '^ *+' conftest.er1 >conftest.err
12822   rm -f conftest.er1
12823   cat conftest.err >&5
12824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12825   (exit $ac_status); } &&
12826          { ac_try='test -z "$ac_c_werror_flag"
12827                          || test ! -s conftest.err'
12828   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12829   (eval $ac_try) 2>&5
12830   ac_status=$?
12831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12832   (exit $ac_status); }; } &&
12833          { ac_try='test -s conftest.$ac_objext'
12834   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12835   (eval $ac_try) 2>&5
12836   ac_status=$?
12837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12838   (exit $ac_status); }; }; then
12839   echo "$as_me:$LINENO: result: yes" >&5
12840 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12841 else
12842   echo "$as_me: failed program was:" >&5
12843 sed 's/^/| /' conftest.$ac_ext >&5
12844
12845 echo "$as_me:$LINENO: result: no" >&5
12846 echo "${ECHO_T}no" >&6
12847 fi
12848 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12849
12850   CFLAGS="$saved_CFLAGS"
12851 fi
12852
12853
12854
12855 # Enable --enable-checking in stage1 of the compiler.
12856 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12857 if test "${enable_stage1_checking+set}" = set; then
12858   enableval="$enable_stage1_checking"
12859   stage1_checking=--enable-checking=${enable_stage1_checking}
12860 else
12861   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12862   stage1_checking=--enable-checking=yes,types
12863 else
12864   stage1_checking=--enable-checking=$enable_checking,types
12865 fi
12866 fi;
12867
12868
12869 # Enable -Werror in bootstrap stage2 and later.
12870 # Check whether --enable-werror or --disable-werror was given.
12871 if test "${enable_werror+set}" = set; then
12872   enableval="$enable_werror"
12873
12874 else
12875   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12876   enable_werror=yes
12877 else
12878   enable_werror=no
12879 fi
12880 fi;
12881 case ${enable_werror} in
12882   yes) stage2_werror_flag="--enable-werror-always" ;;
12883   *) stage2_werror_flag="" ;;
12884 esac
12885
12886
12887 # Flags needed to enable html installing and building
12888
12889 # Check whether --with-datarootdir or --without-datarootdir was given.
12890 if test "${with_datarootdir+set}" = set; then
12891   withval="$with_datarootdir"
12892   datarootdir="\${prefix}/${withval}"
12893 else
12894   datarootdir="\${prefix}/share"
12895 fi;
12896
12897
12898 # Check whether --with-docdir or --without-docdir was given.
12899 if test "${with_docdir+set}" = set; then
12900   withval="$with_docdir"
12901   docdir="\${prefix}/${withval}"
12902 else
12903   docdir="\${datarootdir}/doc"
12904 fi;
12905
12906
12907 # Check whether --with-pdfdir or --without-pdfdir was given.
12908 if test "${with_pdfdir+set}" = set; then
12909   withval="$with_pdfdir"
12910   pdfdir="\${prefix}/${withval}"
12911 else
12912   pdfdir="\${docdir}"
12913 fi;
12914
12915
12916 # Check whether --with-htmldir or --without-htmldir was given.
12917 if test "${with_htmldir+set}" = set; then
12918   withval="$with_htmldir"
12919   htmldir="\${prefix}/${withval}"
12920 else
12921   htmldir="\${docdir}"
12922 fi;
12923
12924
12925
12926
12927
12928
12929 # Specify what files to not compare during bootstrap.
12930
12931 compare_exclusions="gcc/cc*-checksum\$(objext) | gcc/ada/*tools/*"
12932 case "$target" in
12933   hppa*64*-*-hpux*) ;;
12934   hppa*-*-hpux*) compare_exclusions="gcc/cc*-checksum\$(objext) | */libgcc/lib2funcs* | gcc/ada/*tools/*" ;;
12935 esac
12936
12937
12938           ac_config_files="$ac_config_files Makefile"
12939 cat >confcache <<\_ACEOF
12940 # This file is a shell script that caches the results of configure
12941 # tests run on this system so they can be shared between configure
12942 # scripts and configure runs, see configure's option --config-cache.
12943 # It is not useful on other systems.  If it contains results you don't
12944 # want to keep, you may remove or edit it.
12945 #
12946 # config.status only pays attention to the cache file if you give it
12947 # the --recheck option to rerun configure.
12948 #
12949 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12950 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12951 # following values.
12952
12953 _ACEOF
12954
12955 # The following way of writing the cache mishandles newlines in values,
12956 # but we know of no workaround that is simple, portable, and efficient.
12957 # So, don't put newlines in cache variables' values.
12958 # Ultrix sh set writes to stderr and can't be redirected directly,
12959 # and sets the high bit in the cache file unless we assign to the vars.
12960 {
12961   (set) 2>&1 |
12962     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12963     *ac_space=\ *)
12964       # `set' does not quote correctly, so add quotes (double-quote
12965       # substitution turns \\\\ into \\, and sed turns \\ into \).
12966       sed -n \
12967         "s/'/'\\\\''/g;
12968           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12969       ;;
12970     *)
12971       # `set' quotes correctly as required by POSIX, so do not add quotes.
12972       sed -n \
12973         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12974       ;;
12975     esac;
12976 } |
12977   sed '
12978      t clear
12979      : clear
12980      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12981      t end
12982      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12983      : end' >>confcache
12984 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12985   if test -w $cache_file; then
12986     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12987     cat confcache >$cache_file
12988   else
12989     echo "not updating unwritable cache $cache_file"
12990   fi
12991 fi
12992 rm -f confcache
12993
12994 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12995 # Let make expand exec_prefix.
12996 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12997
12998 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12999 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
13000 # trailing colons and then remove the whole line if VPATH becomes empty
13001 # (actually we leave an empty line to preserve line numbers).
13002 if test "x$srcdir" = x.; then
13003   ac_vpsub='/^[  ]*VPATH[        ]*=/{
13004 s/:*\$(srcdir):*/:/;
13005 s/:*\${srcdir}:*/:/;
13006 s/:*@srcdir@:*/:/;
13007 s/^\([^=]*=[     ]*\):*/\1/;
13008 s/:*$//;
13009 s/^[^=]*=[       ]*$//;
13010 }'
13011 fi
13012
13013 # Transform confdefs.h into DEFS.
13014 # Protect against shell expansion while executing Makefile rules.
13015 # Protect against Makefile macro expansion.
13016 #
13017 # If the first sed substitution is executed (which looks for macros that
13018 # take arguments), then we branch to the quote section.  Otherwise,
13019 # look for a macro that doesn't take arguments.
13020 cat >confdef2opt.sed <<\_ACEOF
13021 t clear
13022 : clear
13023 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
13024 t quote
13025 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
13026 t quote
13027 d
13028 : quote
13029 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
13030 s,\[,\\&,g
13031 s,\],\\&,g
13032 s,\$,$$,g
13033 p
13034 _ACEOF
13035 # We use echo to avoid assuming a particular line-breaking character.
13036 # The extra dot is to prevent the shell from consuming trailing
13037 # line-breaks from the sub-command output.  A line-break within
13038 # single-quotes doesn't work because, if this script is created in a
13039 # platform that uses two characters for line-breaks (e.g., DOS), tr
13040 # would break.
13041 ac_LF_and_DOT=`echo; echo .`
13042 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
13043 rm -f confdef2opt.sed
13044
13045
13046 ac_libobjs=
13047 ac_ltlibobjs=
13048 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
13049   # 1. Remove the extension, and $U if already installed.
13050   ac_i=`echo "$ac_i" |
13051          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
13052   # 2. Add them.
13053   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
13054   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
13055 done
13056 LIBOBJS=$ac_libobjs
13057
13058 LTLIBOBJS=$ac_ltlibobjs
13059
13060
13061
13062 : ${CONFIG_STATUS=./config.status}
13063 ac_clean_files_save=$ac_clean_files
13064 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
13065 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
13066 echo "$as_me: creating $CONFIG_STATUS" >&6;}
13067 cat >$CONFIG_STATUS <<_ACEOF
13068 #! $SHELL
13069 # Generated by $as_me.
13070 # Run this file to recreate the current configuration.
13071 # Compiler output produced by configure, useful for debugging
13072 # configure, is in config.log if it exists.
13073
13074 debug=false
13075 ac_cs_recheck=false
13076 ac_cs_silent=false
13077 SHELL=\${CONFIG_SHELL-$SHELL}
13078 _ACEOF
13079
13080 cat >>$CONFIG_STATUS <<\_ACEOF
13081 ## --------------------- ##
13082 ## M4sh Initialization.  ##
13083 ## --------------------- ##
13084
13085 # Be Bourne compatible
13086 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
13087   emulate sh
13088   NULLCMD=:
13089   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
13090   # is contrary to our usage.  Disable this feature.
13091   alias -g '${1+"$@"}'='"$@"'
13092 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
13093   set -o posix
13094 fi
13095 DUALCASE=1; export DUALCASE # for MKS sh
13096
13097 # Support unset when possible.
13098 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13099   as_unset=unset
13100 else
13101   as_unset=false
13102 fi
13103
13104
13105 # Work around bugs in pre-3.0 UWIN ksh.
13106 $as_unset ENV MAIL MAILPATH
13107 PS1='$ '
13108 PS2='> '
13109 PS4='+ '
13110
13111 # NLS nuisances.
13112 for as_var in \
13113   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13114   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13115   LC_TELEPHONE LC_TIME
13116 do
13117   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13118     eval $as_var=C; export $as_var
13119   else
13120     $as_unset $as_var
13121   fi
13122 done
13123
13124 # Required to use basename.
13125 if expr a : '\(a\)' >/dev/null 2>&1; then
13126   as_expr=expr
13127 else
13128   as_expr=false
13129 fi
13130
13131 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13132   as_basename=basename
13133 else
13134   as_basename=false
13135 fi
13136
13137
13138 # Name of the executable.
13139 as_me=`$as_basename "$0" ||
13140 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13141          X"$0" : 'X\(//\)$' \| \
13142          X"$0" : 'X\(/\)$' \| \
13143          .     : '\(.\)' 2>/dev/null ||
13144 echo X/"$0" |
13145     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13146           /^X\/\(\/\/\)$/{ s//\1/; q; }
13147           /^X\/\(\/\).*/{ s//\1/; q; }
13148           s/.*/./; q'`
13149
13150
13151 # PATH needs CR, and LINENO needs CR and PATH.
13152 # Avoid depending upon Character Ranges.
13153 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13154 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13155 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13156 as_cr_digits='0123456789'
13157 as_cr_alnum=$as_cr_Letters$as_cr_digits
13158
13159 # The user is always right.
13160 if test "${PATH_SEPARATOR+set}" != set; then
13161   echo "#! /bin/sh" >conf$$.sh
13162   echo  "exit 0"   >>conf$$.sh
13163   chmod +x conf$$.sh
13164   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13165     PATH_SEPARATOR=';'
13166   else
13167     PATH_SEPARATOR=:
13168   fi
13169   rm -f conf$$.sh
13170 fi
13171
13172
13173   as_lineno_1=$LINENO
13174   as_lineno_2=$LINENO
13175   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13176   test "x$as_lineno_1" != "x$as_lineno_2" &&
13177   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13178   # Find who we are.  Look in the path if we contain no path at all
13179   # relative or not.
13180   case $0 in
13181     *[\\/]* ) as_myself=$0 ;;
13182     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13183 for as_dir in $PATH
13184 do
13185   IFS=$as_save_IFS
13186   test -z "$as_dir" && as_dir=.
13187   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13188 done
13189
13190        ;;
13191   esac
13192   # We did not find ourselves, most probably we were run as `sh COMMAND'
13193   # in which case we are not to be found in the path.
13194   if test "x$as_myself" = x; then
13195     as_myself=$0
13196   fi
13197   if test ! -f "$as_myself"; then
13198     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13199 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13200    { (exit 1); exit 1; }; }
13201   fi
13202   case $CONFIG_SHELL in
13203   '')
13204     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13205 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13206 do
13207   IFS=$as_save_IFS
13208   test -z "$as_dir" && as_dir=.
13209   for as_base in sh bash ksh sh5; do
13210          case $as_dir in
13211          /*)
13212            if ("$as_dir/$as_base" -c '
13213   as_lineno_1=$LINENO
13214   as_lineno_2=$LINENO
13215   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13216   test "x$as_lineno_1" != "x$as_lineno_2" &&
13217   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13218              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13219              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13220              CONFIG_SHELL=$as_dir/$as_base
13221              export CONFIG_SHELL
13222              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13223            fi;;
13224          esac
13225        done
13226 done
13227 ;;
13228   esac
13229
13230   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13231   # uniformly replaced by the line number.  The first 'sed' inserts a
13232   # line-number line before each line; the second 'sed' does the real
13233   # work.  The second script uses 'N' to pair each line-number line
13234   # with the numbered line, and appends trailing '-' during
13235   # substitution so that $LINENO is not a special case at line end.
13236   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13237   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13238   sed '=' <$as_myself |
13239     sed '
13240       N
13241       s,$,-,
13242       : loop
13243       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13244       t loop
13245       s,-$,,
13246       s,^['$as_cr_digits']*\n,,
13247     ' >$as_me.lineno &&
13248   chmod +x $as_me.lineno ||
13249     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13250 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13251    { (exit 1); exit 1; }; }
13252
13253   # Don't try to exec as it changes $[0], causing all sort of problems
13254   # (the dirname of $[0] is not the place where we might find the
13255   # original and so on.  Autoconf is especially sensible to this).
13256   . ./$as_me.lineno
13257   # Exit status is that of the last command.
13258   exit
13259 }
13260
13261
13262 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13263   *c*,-n*) ECHO_N= ECHO_C='
13264 ' ECHO_T='      ' ;;
13265   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13266   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13267 esac
13268
13269 if expr a : '\(a\)' >/dev/null 2>&1; then
13270   as_expr=expr
13271 else
13272   as_expr=false
13273 fi
13274
13275 rm -f conf$$ conf$$.exe conf$$.file
13276 echo >conf$$.file
13277 if ln -s conf$$.file conf$$ 2>/dev/null; then
13278   # We could just check for DJGPP; but this test a) works b) is more generic
13279   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13280   if test -f conf$$.exe; then
13281     # Don't use ln at all; we don't have any links
13282     as_ln_s='cp -p'
13283   else
13284     as_ln_s='ln -s'
13285   fi
13286 elif ln conf$$.file conf$$ 2>/dev/null; then
13287   as_ln_s=ln
13288 else
13289   as_ln_s='cp -p'
13290 fi
13291 rm -f conf$$ conf$$.exe conf$$.file
13292
13293 if mkdir -p . 2>/dev/null; then
13294   as_mkdir_p=:
13295 else
13296   test -d ./-p && rmdir ./-p
13297   as_mkdir_p=false
13298 fi
13299
13300 as_executable_p="test -f"
13301
13302 # Sed expression to map a string onto a valid CPP name.
13303 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13304
13305 # Sed expression to map a string onto a valid variable name.
13306 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13307
13308
13309 # IFS
13310 # We need space, tab and new line, in precisely that order.
13311 as_nl='
13312 '
13313 IFS="   $as_nl"
13314
13315 # CDPATH.
13316 $as_unset CDPATH
13317
13318 exec 6>&1
13319
13320 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13321 # report actual input values of CONFIG_FILES etc. instead of their
13322 # values after options handling.  Logging --version etc. is OK.
13323 exec 5>>config.log
13324 {
13325   echo
13326   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13327 ## Running $as_me. ##
13328 _ASBOX
13329 } >&5
13330 cat >&5 <<_CSEOF
13331
13332 This file was extended by $as_me, which was
13333 generated by GNU Autoconf 2.59.  Invocation command line was
13334
13335   CONFIG_FILES    = $CONFIG_FILES
13336   CONFIG_HEADERS  = $CONFIG_HEADERS
13337   CONFIG_LINKS    = $CONFIG_LINKS
13338   CONFIG_COMMANDS = $CONFIG_COMMANDS
13339   $ $0 $@
13340
13341 _CSEOF
13342 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13343 echo >&5
13344 _ACEOF
13345
13346 # Files that config.status was made for.
13347 if test -n "$ac_config_files"; then
13348   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13349 fi
13350
13351 if test -n "$ac_config_headers"; then
13352   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13353 fi
13354
13355 if test -n "$ac_config_links"; then
13356   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13357 fi
13358
13359 if test -n "$ac_config_commands"; then
13360   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13361 fi
13362
13363 cat >>$CONFIG_STATUS <<\_ACEOF
13364
13365 ac_cs_usage="\
13366 \`$as_me' instantiates files from templates according to the
13367 current configuration.
13368
13369 Usage: $0 [OPTIONS] [FILE]...
13370
13371   -h, --help       print this help, then exit
13372   -V, --version    print version number, then exit
13373   -q, --quiet      do not print progress messages
13374   -d, --debug      don't remove temporary files
13375       --recheck    update $as_me by reconfiguring in the same conditions
13376   --file=FILE[:TEMPLATE]
13377                    instantiate the configuration file FILE
13378
13379 Configuration files:
13380 $config_files
13381
13382 Report bugs to <bug-autoconf@gnu.org>."
13383 _ACEOF
13384
13385 cat >>$CONFIG_STATUS <<_ACEOF
13386 ac_cs_version="\\
13387 config.status
13388 configured by $0, generated by GNU Autoconf 2.59,
13389   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13390
13391 Copyright (C) 2003 Free Software Foundation, Inc.
13392 This config.status script is free software; the Free Software Foundation
13393 gives unlimited permission to copy, distribute and modify it."
13394 srcdir=$srcdir
13395 INSTALL="$INSTALL"
13396 _ACEOF
13397
13398 cat >>$CONFIG_STATUS <<\_ACEOF
13399 # If no file are specified by the user, then we need to provide default
13400 # value.  By we need to know if files were specified by the user.
13401 ac_need_defaults=:
13402 while test $# != 0
13403 do
13404   case $1 in
13405   --*=*)
13406     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13407     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13408     ac_shift=:
13409     ;;
13410   -*)
13411     ac_option=$1
13412     ac_optarg=$2
13413     ac_shift=shift
13414     ;;
13415   *) # This is not an option, so the user has probably given explicit
13416      # arguments.
13417      ac_option=$1
13418      ac_need_defaults=false;;
13419   esac
13420
13421   case $ac_option in
13422   # Handling of the options.
13423 _ACEOF
13424 cat >>$CONFIG_STATUS <<\_ACEOF
13425   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13426     ac_cs_recheck=: ;;
13427   --version | --vers* | -V )
13428     echo "$ac_cs_version"; exit 0 ;;
13429   --he | --h)
13430     # Conflict between --help and --header
13431     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13432 Try \`$0 --help' for more information." >&5
13433 echo "$as_me: error: ambiguous option: $1
13434 Try \`$0 --help' for more information." >&2;}
13435    { (exit 1); exit 1; }; };;
13436   --help | --hel | -h )
13437     echo "$ac_cs_usage"; exit 0 ;;
13438   --debug | --d* | -d )
13439     debug=: ;;
13440   --file | --fil | --fi | --f )
13441     $ac_shift
13442     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13443     ac_need_defaults=false;;
13444   --header | --heade | --head | --hea )
13445     $ac_shift
13446     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13447     ac_need_defaults=false;;
13448   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13449   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13450     ac_cs_silent=: ;;
13451
13452   # This is an error.
13453   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13454 Try \`$0 --help' for more information." >&5
13455 echo "$as_me: error: unrecognized option: $1
13456 Try \`$0 --help' for more information." >&2;}
13457    { (exit 1); exit 1; }; } ;;
13458
13459   *) ac_config_targets="$ac_config_targets $1" ;;
13460
13461   esac
13462   shift
13463 done
13464
13465 ac_configure_extra_args=
13466
13467 if $ac_cs_silent; then
13468   exec 6>/dev/null
13469   ac_configure_extra_args="$ac_configure_extra_args --silent"
13470 fi
13471
13472 _ACEOF
13473 cat >>$CONFIG_STATUS <<_ACEOF
13474 if \$ac_cs_recheck; then
13475   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13476   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13477 fi
13478
13479 _ACEOF
13480
13481
13482
13483
13484
13485 cat >>$CONFIG_STATUS <<\_ACEOF
13486 for ac_config_target in $ac_config_targets
13487 do
13488   case "$ac_config_target" in
13489   # Handling of arguments.
13490   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13491   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13492 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13493    { (exit 1); exit 1; }; };;
13494   esac
13495 done
13496
13497 # If the user did not use the arguments to specify the items to instantiate,
13498 # then the envvar interface is used.  Set only those that are not.
13499 # We use the long form for the default assignment because of an extremely
13500 # bizarre bug on SunOS 4.1.3.
13501 if $ac_need_defaults; then
13502   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13503 fi
13504
13505 # Have a temporary directory for convenience.  Make it in the build tree
13506 # simply because there is no reason to put it here, and in addition,
13507 # creating and moving files from /tmp can sometimes cause problems.
13508 # Create a temporary directory, and hook for its removal unless debugging.
13509 $debug ||
13510 {
13511   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13512   trap '{ (exit 1); exit 1; }' 1 2 13 15
13513 }
13514
13515 # Create a (secure) tmp directory for tmp files.
13516
13517 {
13518   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13519   test -n "$tmp" && test -d "$tmp"
13520 }  ||
13521 {
13522   tmp=./confstat$$-$RANDOM
13523   (umask 077 && mkdir $tmp)
13524 } ||
13525 {
13526    echo "$me: cannot create a temporary directory in ." >&2
13527    { (exit 1); exit 1; }
13528 }
13529
13530 _ACEOF
13531
13532 cat >>$CONFIG_STATUS <<_ACEOF
13533
13534 #
13535 # CONFIG_FILES section.
13536 #
13537
13538 # No need to generate the scripts if there are no CONFIG_FILES.
13539 # This happens for instance when ./config.status config.h
13540 if test -n "\$CONFIG_FILES"; then
13541   # Protect against being on the right side of a sed subst in config.status.
13542   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13543    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13544 s,@SHELL@,$SHELL,;t t
13545 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13546 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13547 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13548 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13549 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13550 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13551 s,@exec_prefix@,$exec_prefix,;t t
13552 s,@prefix@,$prefix,;t t
13553 s,@program_transform_name@,$program_transform_name,;t t
13554 s,@bindir@,$bindir,;t t
13555 s,@sbindir@,$sbindir,;t t
13556 s,@libexecdir@,$libexecdir,;t t
13557 s,@datadir@,$datadir,;t t
13558 s,@sysconfdir@,$sysconfdir,;t t
13559 s,@sharedstatedir@,$sharedstatedir,;t t
13560 s,@localstatedir@,$localstatedir,;t t
13561 s,@libdir@,$libdir,;t t
13562 s,@includedir@,$includedir,;t t
13563 s,@oldincludedir@,$oldincludedir,;t t
13564 s,@infodir@,$infodir,;t t
13565 s,@mandir@,$mandir,;t t
13566 s,@build_alias@,$build_alias,;t t
13567 s,@host_alias@,$host_alias,;t t
13568 s,@target_alias@,$target_alias,;t t
13569 s,@DEFS@,$DEFS,;t t
13570 s,@ECHO_C@,$ECHO_C,;t t
13571 s,@ECHO_N@,$ECHO_N,;t t
13572 s,@ECHO_T@,$ECHO_T,;t t
13573 s,@LIBS@,$LIBS,;t t
13574 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13575 s,@build@,$build,;t t
13576 s,@build_cpu@,$build_cpu,;t t
13577 s,@build_vendor@,$build_vendor,;t t
13578 s,@build_os@,$build_os,;t t
13579 s,@build_noncanonical@,$build_noncanonical,;t t
13580 s,@host_noncanonical@,$host_noncanonical,;t t
13581 s,@target_noncanonical@,$target_noncanonical,;t t
13582 s,@host@,$host,;t t
13583 s,@host_cpu@,$host_cpu,;t t
13584 s,@host_vendor@,$host_vendor,;t t
13585 s,@host_os@,$host_os,;t t
13586 s,@target@,$target,;t t
13587 s,@target_cpu@,$target_cpu,;t t
13588 s,@target_vendor@,$target_vendor,;t t
13589 s,@target_os@,$target_os,;t t
13590 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13591 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13592 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13593 s,@LN@,$LN,;t t
13594 s,@LN_S@,$LN_S,;t t
13595 s,@build_libsubdir@,$build_libsubdir,;t t
13596 s,@build_subdir@,$build_subdir,;t t
13597 s,@host_subdir@,$host_subdir,;t t
13598 s,@target_subdir@,$target_subdir,;t t
13599 s,@CC@,$CC,;t t
13600 s,@CFLAGS@,$CFLAGS,;t t
13601 s,@LDFLAGS@,$LDFLAGS,;t t
13602 s,@CPPFLAGS@,$CPPFLAGS,;t t
13603 s,@ac_ct_CC@,$ac_ct_CC,;t t
13604 s,@EXEEXT@,$EXEEXT,;t t
13605 s,@OBJEXT@,$OBJEXT,;t t
13606 s,@CXX@,$CXX,;t t
13607 s,@CXXFLAGS@,$CXXFLAGS,;t t
13608 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13609 s,@GNATBIND@,$GNATBIND,;t t
13610 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13611 s,@GNATMAKE@,$GNATMAKE,;t t
13612 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13613 s,@do_compare@,$do_compare,;t t
13614 s,@gmplibs@,$gmplibs,;t t
13615 s,@gmpinc@,$gmpinc,;t t
13616 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13617 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13618 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13619 s,@stage1_ldflags@,$stage1_ldflags,;t t
13620 s,@stage1_libs@,$stage1_libs,;t t
13621 s,@poststage1_ldflags@,$poststage1_ldflags,;t t
13622 s,@poststage1_libs@,$poststage1_libs,;t t
13623 s,@ppllibs@,$ppllibs,;t t
13624 s,@pplinc@,$pplinc,;t t
13625 s,@clooglibs@,$clooglibs,;t t
13626 s,@clooginc@,$clooginc,;t t
13627 s,@stage1_languages@,$stage1_languages,;t t
13628 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13629 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13630 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13631 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13632 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13633 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13634 s,@tooldir@,$tooldir,;t t
13635 s,@build_tooldir@,$build_tooldir,;t t
13636 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13637 s,@GDB_TK@,$GDB_TK,;t t
13638 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13639 s,@build_configargs@,$build_configargs,;t t
13640 s,@build_configdirs@,$build_configdirs,;t t
13641 s,@host_configargs@,$host_configargs,;t t
13642 s,@configdirs@,$configdirs,;t t
13643 s,@target_configargs@,$target_configargs,;t t
13644 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13645 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13646 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13647 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13648 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13649 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13650 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13651 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13652 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13653 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13654 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13655 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13656 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13657 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13658 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13659 s,@config_shell@,$config_shell,;t t
13660 s,@YACC@,$YACC,;t t
13661 s,@BISON@,$BISON,;t t
13662 s,@M4@,$M4,;t t
13663 s,@LEX@,$LEX,;t t
13664 s,@FLEX@,$FLEX,;t t
13665 s,@MAKEINFO@,$MAKEINFO,;t t
13666 s,@EXPECT@,$EXPECT,;t t
13667 s,@RUNTEST@,$RUNTEST,;t t
13668 s,@AR@,$AR,;t t
13669 s,@AS@,$AS,;t t
13670 s,@DLLTOOL@,$DLLTOOL,;t t
13671 s,@LD@,$LD,;t t
13672 s,@LIPO@,$LIPO,;t t
13673 s,@NM@,$NM,;t t
13674 s,@RANLIB@,$RANLIB,;t t
13675 s,@STRIP@,$STRIP,;t t
13676 s,@WINDRES@,$WINDRES,;t t
13677 s,@WINDMC@,$WINDMC,;t t
13678 s,@OBJCOPY@,$OBJCOPY,;t t
13679 s,@OBJDUMP@,$OBJDUMP,;t t
13680 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13681 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13682 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13683 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13684 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13685 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13686 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13687 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13688 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13689 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13690 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13691 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13692 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13693 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13694 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13695 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13696 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13697 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13698 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13699 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13700 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13701 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13702 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13703 s,@MAINT@,$MAINT,;t t
13704 s,@stage1_cflags@,$stage1_cflags,;t t
13705 s,@stage1_checking@,$stage1_checking,;t t
13706 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13707 s,@datarootdir@,$datarootdir,;t t
13708 s,@docdir@,$docdir,;t t
13709 s,@pdfdir@,$pdfdir,;t t
13710 s,@htmldir@,$htmldir,;t t
13711 s,@compare_exclusions@,$compare_exclusions,;t t
13712 s,@LIBOBJS@,$LIBOBJS,;t t
13713 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13714 /@serialization_dependencies@/r $serialization_dependencies
13715 s,@serialization_dependencies@,,;t t
13716 /@host_makefile_frag@/r $host_makefile_frag
13717 s,@host_makefile_frag@,,;t t
13718 /@target_makefile_frag@/r $target_makefile_frag
13719 s,@target_makefile_frag@,,;t t
13720 /@alphaieee_frag@/r $alphaieee_frag
13721 s,@alphaieee_frag@,,;t t
13722 /@ospace_frag@/r $ospace_frag
13723 s,@ospace_frag@,,;t t
13724 CEOF
13725
13726 _ACEOF
13727
13728   cat >>$CONFIG_STATUS <<\_ACEOF
13729   # Split the substitutions into bite-sized pieces for seds with
13730   # small command number limits, like on Digital OSF/1 and HP-UX.
13731   ac_max_sed_lines=48
13732   ac_sed_frag=1 # Number of current file.
13733   ac_beg=1 # First line for current file.
13734   ac_end=$ac_max_sed_lines # Line after last line for current file.
13735   ac_more_lines=:
13736   ac_sed_cmds=
13737   while $ac_more_lines; do
13738     if test $ac_beg -gt 1; then
13739       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13740     else
13741       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13742     fi
13743     if test ! -s $tmp/subs.frag; then
13744       ac_more_lines=false
13745     else
13746       # The purpose of the label and of the branching condition is to
13747       # speed up the sed processing (if there are no `@' at all, there
13748       # is no need to browse any of the substitutions).
13749       # These are the two extra sed commands mentioned above.
13750       (echo ':t
13751   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13752       if test -z "$ac_sed_cmds"; then
13753         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13754       else
13755         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13756       fi
13757       ac_sed_frag=`expr $ac_sed_frag + 1`
13758       ac_beg=$ac_end
13759       ac_end=`expr $ac_end + $ac_max_sed_lines`
13760     fi
13761   done
13762   if test -z "$ac_sed_cmds"; then
13763     ac_sed_cmds=cat
13764   fi
13765 fi # test -n "$CONFIG_FILES"
13766
13767 _ACEOF
13768 cat >>$CONFIG_STATUS <<\_ACEOF
13769 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13770   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13771   case $ac_file in
13772   - | *:- | *:-:* ) # input from stdin
13773         cat >$tmp/stdin
13774         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13775         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13776   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13777         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13778   * )   ac_file_in=$ac_file.in ;;
13779   esac
13780
13781   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13782   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13783 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13784          X"$ac_file" : 'X\(//\)[^/]' \| \
13785          X"$ac_file" : 'X\(//\)$' \| \
13786          X"$ac_file" : 'X\(/\)' \| \
13787          .     : '\(.\)' 2>/dev/null ||
13788 echo X"$ac_file" |
13789     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13790           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13791           /^X\(\/\/\)$/{ s//\1/; q; }
13792           /^X\(\/\).*/{ s//\1/; q; }
13793           s/.*/./; q'`
13794   { if $as_mkdir_p; then
13795     mkdir -p "$ac_dir"
13796   else
13797     as_dir="$ac_dir"
13798     as_dirs=
13799     while test ! -d "$as_dir"; do
13800       as_dirs="$as_dir $as_dirs"
13801       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13802 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13803          X"$as_dir" : 'X\(//\)[^/]' \| \
13804          X"$as_dir" : 'X\(//\)$' \| \
13805          X"$as_dir" : 'X\(/\)' \| \
13806          .     : '\(.\)' 2>/dev/null ||
13807 echo X"$as_dir" |
13808     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13809           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13810           /^X\(\/\/\)$/{ s//\1/; q; }
13811           /^X\(\/\).*/{ s//\1/; q; }
13812           s/.*/./; q'`
13813     done
13814     test ! -n "$as_dirs" || mkdir $as_dirs
13815   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13816 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13817    { (exit 1); exit 1; }; }; }
13818
13819   ac_builddir=.
13820
13821 if test "$ac_dir" != .; then
13822   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13823   # A "../" for each directory in $ac_dir_suffix.
13824   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13825 else
13826   ac_dir_suffix= ac_top_builddir=
13827 fi
13828
13829 case $srcdir in
13830   .)  # No --srcdir option.  We are building in place.
13831     ac_srcdir=.
13832     if test -z "$ac_top_builddir"; then
13833        ac_top_srcdir=.
13834     else
13835        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13836     fi ;;
13837   [\\/]* | ?:[\\/]* )  # Absolute path.
13838     ac_srcdir=$srcdir$ac_dir_suffix;
13839     ac_top_srcdir=$srcdir ;;
13840   *) # Relative path.
13841     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13842     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13843 esac
13844
13845 # Do not use `cd foo && pwd` to compute absolute paths, because
13846 # the directories may not exist.
13847 case `pwd` in
13848 .) ac_abs_builddir="$ac_dir";;
13849 *)
13850   case "$ac_dir" in
13851   .) ac_abs_builddir=`pwd`;;
13852   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13853   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13854   esac;;
13855 esac
13856 case $ac_abs_builddir in
13857 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13858 *)
13859   case ${ac_top_builddir}. in
13860   .) ac_abs_top_builddir=$ac_abs_builddir;;
13861   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13862   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13863   esac;;
13864 esac
13865 case $ac_abs_builddir in
13866 .) ac_abs_srcdir=$ac_srcdir;;
13867 *)
13868   case $ac_srcdir in
13869   .) ac_abs_srcdir=$ac_abs_builddir;;
13870   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13871   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13872   esac;;
13873 esac
13874 case $ac_abs_builddir in
13875 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13876 *)
13877   case $ac_top_srcdir in
13878   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13879   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13880   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13881   esac;;
13882 esac
13883
13884
13885   case $INSTALL in
13886   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13887   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13888   esac
13889
13890   if test x"$ac_file" != x-; then
13891     { echo "$as_me:$LINENO: creating $ac_file" >&5
13892 echo "$as_me: creating $ac_file" >&6;}
13893     rm -f "$ac_file"
13894   fi
13895   # Let's still pretend it is `configure' which instantiates (i.e., don't
13896   # use $as_me), people would be surprised to read:
13897   #    /* config.h.  Generated by config.status.  */
13898   if test x"$ac_file" = x-; then
13899     configure_input=
13900   else
13901     configure_input="$ac_file.  "
13902   fi
13903   configure_input=$configure_input"Generated from `echo $ac_file_in |
13904                                      sed 's,.*/,,'` by configure."
13905
13906   # First look for the input files in the build tree, otherwise in the
13907   # src tree.
13908   ac_file_inputs=`IFS=:
13909     for f in $ac_file_in; do
13910       case $f in
13911       -) echo $tmp/stdin ;;
13912       [\\/$]*)
13913          # Absolute (can't be DOS-style, as IFS=:)
13914          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13915 echo "$as_me: error: cannot find input file: $f" >&2;}
13916    { (exit 1); exit 1; }; }
13917          echo "$f";;
13918       *) # Relative
13919          if test -f "$f"; then
13920            # Build tree
13921            echo "$f"
13922          elif test -f "$srcdir/$f"; then
13923            # Source tree
13924            echo "$srcdir/$f"
13925          else
13926            # /dev/null tree
13927            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13928 echo "$as_me: error: cannot find input file: $f" >&2;}
13929    { (exit 1); exit 1; }; }
13930          fi;;
13931       esac
13932     done` || { (exit 1); exit 1; }
13933 _ACEOF
13934 cat >>$CONFIG_STATUS <<_ACEOF
13935   sed "$ac_vpsub
13936 $extrasub
13937 _ACEOF
13938 cat >>$CONFIG_STATUS <<\_ACEOF
13939 :t
13940 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13941 s,@configure_input@,$configure_input,;t t
13942 s,@srcdir@,$ac_srcdir,;t t
13943 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13944 s,@top_srcdir@,$ac_top_srcdir,;t t
13945 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13946 s,@builddir@,$ac_builddir,;t t
13947 s,@abs_builddir@,$ac_abs_builddir,;t t
13948 s,@top_builddir@,$ac_top_builddir,;t t
13949 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13950 s,@INSTALL@,$ac_INSTALL,;t t
13951 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13952   rm -f $tmp/stdin
13953   if test x"$ac_file" != x-; then
13954     mv $tmp/out $ac_file
13955   else
13956     cat $tmp/out
13957     rm -f $tmp/out
13958   fi
13959
13960 done
13961 _ACEOF
13962
13963 cat >>$CONFIG_STATUS <<\_ACEOF
13964
13965 { (exit 0); exit 0; }
13966 _ACEOF
13967 chmod +x $CONFIG_STATUS
13968 ac_clean_files=$ac_clean_files_save
13969
13970
13971 # configure is writing to config.log, and then calls config.status.
13972 # config.status does its own redirection, appending to config.log.
13973 # Unfortunately, on DOS this fails, as config.log is still kept open
13974 # by configure, so config.status won't be able to write to it; its
13975 # output is simply discarded.  So we exec the FD to /dev/null,
13976 # effectively closing config.log, so it can be properly (re)opened and
13977 # appended to by config.status.  When coming back to configure, we
13978 # need to make the FD available again.
13979 if test "$no_create" != yes; then
13980   ac_cs_success=:
13981   ac_config_status_args=
13982   test "$silent" = yes &&
13983     ac_config_status_args="$ac_config_status_args --quiet"
13984   exec 5>/dev/null
13985   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13986   exec 5>>config.log
13987   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13988   # would make configure fail if this is the last instruction.
13989   $ac_cs_success || { (exit 1); exit 1; }
13990 fi
13991