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 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 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   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpc=PATH        specify prefix directory for installed MPC package.
 960                           Equivalent to --with-mpc-include=PATH/include
 961                           plus --with-mpc-lib=PATH/lib
 962   --with-mpc-include=PATH
 963                           specify directory for installed MPC include files
 964   --with-mpc-lib=PATH    specify directory for the installed MPC library
 965   --with-mpfr-dir=PATH    this option has been REMOVED
 966   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 967                           Equivalent to --with-mpfr-include=PATH/include
 968                           plus --with-mpfr-lib=PATH/lib
 969   --with-mpfr-include=PATH
 970                           specify directory for installed MPFR include files
 971   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 972   --with-gmp-dir=PATH     this option has been REMOVED
 973   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 974                           Equivalent to --with-gmp-include=PATH/include
 975                           plus --with-gmp-lib=PATH/lib
 976   --with-gmp-include=PATH specify directory for installed GMP include files
 977   --with-gmp-lib=PATH     specify directory for the installed GMP library
 978   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 979                           when linking with PPL
 980   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 981                           Equivalent to --with-ppl-include=PATH/include
 982                           plus --with-ppl-lib=PATH/lib
 983   --with-ppl-include=PATH Specify directory for installed PPL include files
 984   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 985   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 986                           Equivalent to --with-cloog-include=PATH/include
 987                           plus --with-cloog-lib=PATH/lib
 988   --with-cloog-include=PATH Specify directory for installed CLooG include files
 989   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 990   --with-build-sysroot=SYSROOT
 991                           use sysroot as the system root during the build
 992   --with-debug-prefix-map='A=B C=D ...'
 993                              map A to B, C to D ... in debug information
 994   --with-build-time-tools=PATH
 995                           use given path to find target tools during the build
 996   --with-datarootdir      use datarootdir as the data root directory.
 997   --with-docdir           install documentation in this directory.
 998   --with-pdfdir           install pdf in this directory.
 999   --with-htmldir          install html in this directory.
1000
1001 Some influential environment variables:
1002   CC          C compiler command
1003   CFLAGS      C compiler flags
1004   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1005               nonstandard directory <lib dir>
1006   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1007               headers in a nonstandard directory <include dir>
1008   CXX         C++ compiler command
1009   CXXFLAGS    C++ compiler flags
1010   AR          AR for the host
1011   AS          AS for the host
1012   DLLTOOL     DLLTOOL for the host
1013   LD          LD for the host
1014   LIPO        LIPO for the host
1015   NM          NM for the host
1016   RANLIB      RANLIB for the host
1017   STRIP       STRIP for the host
1018   WINDRES     WINDRES for the host
1019   WINDMC      WINDMC for the host
1020   OBJCOPY     OBJCOPY for the host
1021   OBJDUMP     OBJDUMP for the host
1022   CC_FOR_TARGET
1023               CC for the target
1024   CXX_FOR_TARGET
1025               CXX for the target
1026   GCC_FOR_TARGET
1027               GCC for the target
1028   GCJ_FOR_TARGET
1029               GCJ for the target
1030   GFORTRAN_FOR_TARGET
1031               GFORTRAN for the target
1032   AR_FOR_TARGET
1033               AR for the target
1034   AS_FOR_TARGET
1035               AS for the target
1036   DLLTOOL_FOR_TARGET
1037               DLLTOOL for the target
1038   LD_FOR_TARGET
1039               LD for the target
1040   LIPO_FOR_TARGET
1041               LIPO for the target
1042   NM_FOR_TARGET
1043               NM for the target
1044   OBJDUMP_FOR_TARGET
1045               OBJDUMP for the target
1046   RANLIB_FOR_TARGET
1047               RANLIB for the target
1048   STRIP_FOR_TARGET
1049               STRIP for the target
1050   WINDRES_FOR_TARGET
1051               WINDRES for the target
1052   WINDMC_FOR_TARGET
1053               WINDMC for the target
1054
1055 Use these variables to override the choices made by `configure' or to help
1056 it to find libraries and programs with nonstandard names/locations.
1057
1058 _ACEOF
1059 fi
1060
1061 if test "$ac_init_help" = "recursive"; then
1062   # If there are subdirs, report their specific --help.
1063   ac_popdir=`pwd`
1064   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1065     test -d $ac_dir || continue
1066     ac_builddir=.
1067
1068 if test "$ac_dir" != .; then
1069   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1070   # A "../" for each directory in $ac_dir_suffix.
1071   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1072 else
1073   ac_dir_suffix= ac_top_builddir=
1074 fi
1075
1076 case $srcdir in
1077   .)  # No --srcdir option.  We are building in place.
1078     ac_srcdir=.
1079     if test -z "$ac_top_builddir"; then
1080        ac_top_srcdir=.
1081     else
1082        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1083     fi ;;
1084   [\\/]* | ?:[\\/]* )  # Absolute path.
1085     ac_srcdir=$srcdir$ac_dir_suffix;
1086     ac_top_srcdir=$srcdir ;;
1087   *) # Relative path.
1088     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1089     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1090 esac
1091
1092 # Do not use `cd foo && pwd` to compute absolute paths, because
1093 # the directories may not exist.
1094 case `pwd` in
1095 .) ac_abs_builddir="$ac_dir";;
1096 *)
1097   case "$ac_dir" in
1098   .) ac_abs_builddir=`pwd`;;
1099   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1100   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1101   esac;;
1102 esac
1103 case $ac_abs_builddir in
1104 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1105 *)
1106   case ${ac_top_builddir}. in
1107   .) ac_abs_top_builddir=$ac_abs_builddir;;
1108   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1109   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1110   esac;;
1111 esac
1112 case $ac_abs_builddir in
1113 .) ac_abs_srcdir=$ac_srcdir;;
1114 *)
1115   case $ac_srcdir in
1116   .) ac_abs_srcdir=$ac_abs_builddir;;
1117   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1118   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1119   esac;;
1120 esac
1121 case $ac_abs_builddir in
1122 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1123 *)
1124   case $ac_top_srcdir in
1125   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1126   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1127   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1128   esac;;
1129 esac
1130
1131     cd $ac_dir
1132     # Check for guested configure; otherwise get Cygnus style configure.
1133     if test -f $ac_srcdir/configure.gnu; then
1134       echo
1135       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1136     elif test -f $ac_srcdir/configure; then
1137       echo
1138       $SHELL $ac_srcdir/configure  --help=recursive
1139     elif test -f $ac_srcdir/configure.ac ||
1140            test -f $ac_srcdir/configure.in; then
1141       echo
1142       $ac_configure --help
1143     else
1144       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1145     fi
1146     cd $ac_popdir
1147   done
1148 fi
1149
1150 test -n "$ac_init_help" && exit 0
1151 if $ac_init_version; then
1152   cat <<\_ACEOF
1153
1154 Copyright (C) 2003 Free Software Foundation, Inc.
1155 This configure script is free software; the Free Software Foundation
1156 gives unlimited permission to copy, distribute and modify it.
1157 _ACEOF
1158   exit 0
1159 fi
1160 exec 5>config.log
1161 cat >&5 <<_ACEOF
1162 This file contains any messages produced by compilers while
1163 running configure, to aid debugging if configure makes a mistake.
1164
1165 It was created by $as_me, which was
1166 generated by GNU Autoconf 2.59.  Invocation command line was
1167
1168   $ $0 $@
1169
1170 _ACEOF
1171 {
1172 cat <<_ASUNAME
1173 ## --------- ##
1174 ## Platform. ##
1175 ## --------- ##
1176
1177 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1178 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1179 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1180 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1181 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1182
1183 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1184 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1185
1186 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1187 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1188 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1189 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1190 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1191 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1192 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1193
1194 _ASUNAME
1195
1196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1197 for as_dir in $PATH
1198 do
1199   IFS=$as_save_IFS
1200   test -z "$as_dir" && as_dir=.
1201   echo "PATH: $as_dir"
1202 done
1203
1204 } >&5
1205
1206 cat >&5 <<_ACEOF
1207
1208
1209 ## ----------- ##
1210 ## Core tests. ##
1211 ## ----------- ##
1212
1213 _ACEOF
1214
1215
1216 # Keep a trace of the command line.
1217 # Strip out --no-create and --no-recursion so they do not pile up.
1218 # Strip out --silent because we don't want to record it for future runs.
1219 # Also quote any args containing shell meta-characters.
1220 # Make two passes to allow for proper duplicate-argument suppression.
1221 ac_configure_args=
1222 ac_configure_args0=
1223 ac_configure_args1=
1224 ac_sep=
1225 ac_must_keep_next=false
1226 for ac_pass in 1 2
1227 do
1228   for ac_arg
1229   do
1230     case $ac_arg in
1231     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1232     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1233     | -silent | --silent | --silen | --sile | --sil)
1234       continue ;;
1235     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1236       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1237     esac
1238     case $ac_pass in
1239     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1240     2)
1241       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1242       if test $ac_must_keep_next = true; then
1243         ac_must_keep_next=false # Got value, back to normal.
1244       else
1245         case $ac_arg in
1246           *=* | --config-cache | -C | -disable-* | --disable-* \
1247           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1248           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1249           | -with-* | --with-* | -without-* | --without-* | --x)
1250             case "$ac_configure_args0 " in
1251               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1252             esac
1253             ;;
1254           -* ) ac_must_keep_next=true ;;
1255         esac
1256       fi
1257       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1258       # Get rid of the leading space.
1259       ac_sep=" "
1260       ;;
1261     esac
1262   done
1263 done
1264 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1265 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1266
1267 # When interrupted or exit'd, cleanup temporary files, and complete
1268 # config.log.  We remove comments because anyway the quotes in there
1269 # would cause problems or look ugly.
1270 # WARNING: Be sure not to use single quotes in there, as some shells,
1271 # such as our DU 5.0 friend, will then `close' the trap.
1272 trap 'exit_status=$?
1273   # Save into config.log some information that might help in debugging.
1274   {
1275     echo
1276
1277     cat <<\_ASBOX
1278 ## ---------------- ##
1279 ## Cache variables. ##
1280 ## ---------------- ##
1281 _ASBOX
1282     echo
1283     # The following way of writing the cache mishandles newlines in values,
1284 {
1285   (set) 2>&1 |
1286     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1287     *ac_space=\ *)
1288       sed -n \
1289         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1290           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1291       ;;
1292     *)
1293       sed -n \
1294         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1295       ;;
1296     esac;
1297 }
1298     echo
1299
1300     cat <<\_ASBOX
1301 ## ----------------- ##
1302 ## Output variables. ##
1303 ## ----------------- ##
1304 _ASBOX
1305     echo
1306     for ac_var in $ac_subst_vars
1307     do
1308       eval ac_val=$`echo $ac_var`
1309       echo "$ac_var='"'"'$ac_val'"'"'"
1310     done | sort
1311     echo
1312
1313     if test -n "$ac_subst_files"; then
1314       cat <<\_ASBOX
1315 ## ------------- ##
1316 ## Output files. ##
1317 ## ------------- ##
1318 _ASBOX
1319       echo
1320       for ac_var in $ac_subst_files
1321       do
1322         eval ac_val=$`echo $ac_var`
1323         echo "$ac_var='"'"'$ac_val'"'"'"
1324       done | sort
1325       echo
1326     fi
1327
1328     if test -s confdefs.h; then
1329       cat <<\_ASBOX
1330 ## ----------- ##
1331 ## confdefs.h. ##
1332 ## ----------- ##
1333 _ASBOX
1334       echo
1335       sed "/^$/d" confdefs.h | sort
1336       echo
1337     fi
1338     test "$ac_signal" != 0 &&
1339       echo "$as_me: caught signal $ac_signal"
1340     echo "$as_me: exit $exit_status"
1341   } >&5
1342   rm -f core *.core &&
1343   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1344     exit $exit_status
1345      ' 0
1346 for ac_signal in 1 2 13 15; do
1347   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1348 done
1349 ac_signal=0
1350
1351 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1352 rm -rf conftest* confdefs.h
1353 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1354 echo >confdefs.h
1355
1356 # Predefined preprocessor variables.
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_NAME "$PACKAGE_NAME"
1360 _ACEOF
1361
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_STRING "$PACKAGE_STRING"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1380 _ACEOF
1381
1382
1383 # Let the site file select an alternate cache file if it wants to.
1384 # Prefer explicitly selected file to automatically selected ones.
1385 if test -z "$CONFIG_SITE"; then
1386   if test "x$prefix" != xNONE; then
1387     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1388   else
1389     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1390   fi
1391 fi
1392 for ac_site_file in $CONFIG_SITE; do
1393   if test -r "$ac_site_file"; then
1394     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1395 echo "$as_me: loading site script $ac_site_file" >&6;}
1396     sed 's/^/| /' "$ac_site_file" >&5
1397     . "$ac_site_file"
1398   fi
1399 done
1400
1401 if test -r "$cache_file"; then
1402   # Some versions of bash will fail to source /dev/null (special
1403   # files actually), so we avoid doing that.
1404   if test -f "$cache_file"; then
1405     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1406 echo "$as_me: loading cache $cache_file" >&6;}
1407     case $cache_file in
1408       [\\/]* | ?:[\\/]* ) . $cache_file;;
1409       *)                      . ./$cache_file;;
1410     esac
1411   fi
1412 else
1413   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1414 echo "$as_me: creating cache $cache_file" >&6;}
1415   >$cache_file
1416 fi
1417
1418 # Check that the precious variables saved in the cache have kept the same
1419 # value.
1420 ac_cache_corrupted=false
1421 for ac_var in `(set) 2>&1 |
1422                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1423   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1424   eval ac_new_set=\$ac_env_${ac_var}_set
1425   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1426   eval ac_new_val="\$ac_env_${ac_var}_value"
1427   case $ac_old_set,$ac_new_set in
1428     set,)
1429       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1430 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1431       ac_cache_corrupted=: ;;
1432     ,set)
1433       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1434 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1435       ac_cache_corrupted=: ;;
1436     ,);;
1437     *)
1438       if test "x$ac_old_val" != "x$ac_new_val"; then
1439         # differences in whitespace do not lead to failure.
1440         ac_old_val_w=`echo x $ac_old_val`
1441         ac_new_val_w=`echo x $ac_new_val`
1442         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1443           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1444 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1445           ac_cache_corrupted=:
1446         else
1447           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1448 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1449           eval $ac_var=\$ac_old_val
1450         fi
1451         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1452 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1453         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1454 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1455       fi;;
1456   esac
1457   # Pass precious variables to config.status.
1458   if test "$ac_new_set" = set; then
1459     case $ac_new_val in
1460     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1461       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1462     *) ac_arg=$ac_var=$ac_new_val ;;
1463     esac
1464     case " $ac_configure_args " in
1465       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1466       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1467     esac
1468   fi
1469 done
1470 if $ac_cache_corrupted; then
1471   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1472 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1473   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1474 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1475   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1476 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1477    { (exit 1); exit 1; }; }
1478 fi
1479
1480 ac_ext=c
1481 ac_cpp='$CPP $CPPFLAGS'
1482 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1483 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1484 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509 progname=$0
1510 # if PWD already has a value, it is probably wrong.
1511 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1512
1513 # Export original configure arguments for use by sub-configures.
1514 # Quote arguments with shell meta charatcers.
1515 TOPLEVEL_CONFIGURE_ARGUMENTS=
1516 set -- "$progname" "$@"
1517 for ac_arg
1518 do
1519   case "$ac_arg" in
1520   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1521     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1522     # if the argument is of the form -foo=baz, quote the baz part only
1523     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1524   *) ;;
1525   esac
1526   # Add the quoted argument to the list.
1527   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1528 done
1529 if test "$silent" = yes; then
1530   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1531 fi
1532 # Remove the initial space we just introduced and, as these will be
1533 # expanded by make, quote '$'.
1534 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1535
1536
1537 # Find the build, host, and target systems.
1538 ac_aux_dir=
1539 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1540   if test -f $ac_dir/install-sh; then
1541     ac_aux_dir=$ac_dir
1542     ac_install_sh="$ac_aux_dir/install-sh -c"
1543     break
1544   elif test -f $ac_dir/install.sh; then
1545     ac_aux_dir=$ac_dir
1546     ac_install_sh="$ac_aux_dir/install.sh -c"
1547     break
1548   elif test -f $ac_dir/shtool; then
1549     ac_aux_dir=$ac_dir
1550     ac_install_sh="$ac_aux_dir/shtool install -c"
1551     break
1552   fi
1553 done
1554 if test -z "$ac_aux_dir"; then
1555   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1556 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1557    { (exit 1); exit 1; }; }
1558 fi
1559 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1560 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1561 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1562
1563 # Make sure we can run config.sub.
1564 $ac_config_sub sun4 >/dev/null 2>&1 ||
1565   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1566 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 echo "$as_me:$LINENO: checking build system type" >&5
1570 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1571 if test "${ac_cv_build+set}" = set; then
1572   echo $ECHO_N "(cached) $ECHO_C" >&6
1573 else
1574   ac_cv_build_alias=$build_alias
1575 test -z "$ac_cv_build_alias" &&
1576   ac_cv_build_alias=`$ac_config_guess`
1577 test -z "$ac_cv_build_alias" &&
1578   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1579 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1580    { (exit 1); exit 1; }; }
1581 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1582   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1583 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1584    { (exit 1); exit 1; }; }
1585
1586 fi
1587 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1588 echo "${ECHO_T}$ac_cv_build" >&6
1589 build=$ac_cv_build
1590 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1591 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1592 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1593
1594
1595  case ${build_alias} in
1596   "") build_noncanonical=${build} ;;
1597   *) build_noncanonical=${build_alias} ;;
1598 esac
1599
1600
1601
1602  case ${host_alias} in
1603   "") host_noncanonical=${build_noncanonical} ;;
1604   *) host_noncanonical=${host_alias} ;;
1605 esac
1606
1607
1608
1609  case ${target_alias} in
1610   "") target_noncanonical=${host_noncanonical} ;;
1611   *) target_noncanonical=${target_alias} ;;
1612 esac
1613
1614
1615
1616
1617 test "$host_noncanonical" = "$target_noncanonical" &&
1618   test "$program_prefix$program_suffix$program_transform_name" = \
1619     NONENONEs,x,x, &&
1620   program_transform_name=s,y,y,
1621
1622 echo "$as_me:$LINENO: checking host system type" >&5
1623 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1624 if test "${ac_cv_host+set}" = set; then
1625   echo $ECHO_N "(cached) $ECHO_C" >&6
1626 else
1627   ac_cv_host_alias=$host_alias
1628 test -z "$ac_cv_host_alias" &&
1629   ac_cv_host_alias=$ac_cv_build_alias
1630 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1631   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1632 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1633    { (exit 1); exit 1; }; }
1634
1635 fi
1636 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1637 echo "${ECHO_T}$ac_cv_host" >&6
1638 host=$ac_cv_host
1639 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1640 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1641 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1642
1643
1644 echo "$as_me:$LINENO: checking target system type" >&5
1645 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1646 if test "${ac_cv_target+set}" = set; then
1647   echo $ECHO_N "(cached) $ECHO_C" >&6
1648 else
1649   ac_cv_target_alias=$target_alias
1650 test "x$ac_cv_target_alias" = "x" &&
1651   ac_cv_target_alias=$ac_cv_host_alias
1652 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1653   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1654 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1655    { (exit 1); exit 1; }; }
1656
1657 fi
1658 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1659 echo "${ECHO_T}$ac_cv_target" >&6
1660 target=$ac_cv_target
1661 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1662 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1663 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1664
1665
1666 # The aliases save the names the user supplied, while $host etc.
1667 # will get canonicalized.
1668 test -n "$target_alias" &&
1669   test "$program_prefix$program_suffix$program_transform_name" = \
1670     NONENONEs,x,x, &&
1671   program_prefix=${target_alias}-
1672 test "$program_prefix" != NONE &&
1673   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1674 # Use a double $ so make ignores it.
1675 test "$program_suffix" != NONE &&
1676   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1677 # Double any \ or $.  echo might interpret backslashes.
1678 # By default was `s,x,x', remove it if useless.
1679 cat <<\_ACEOF >conftest.sed
1680 s/[\\$]/&&/g;s/;s,x,x,$//
1681 _ACEOF
1682 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1683 rm conftest.sed
1684
1685
1686
1687 # Get 'install' or 'install-sh' and its variants.
1688 # Find a good install program.  We prefer a C program (faster),
1689 # so one script is as good as another.  But avoid the broken or
1690 # incompatible versions:
1691 # SysV /etc/install, /usr/sbin/install
1692 # SunOS /usr/etc/install
1693 # IRIX /sbin/install
1694 # AIX /bin/install
1695 # AmigaOS /C/install, which installs bootblocks on floppy discs
1696 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1697 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1698 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1699 # OS/2's system install, which has a completely different semantic
1700 # ./install, which can be erroneously created by make from ./install.sh.
1701 # Reject install programs that cannot install multiple files.
1702 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1703 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1704 if test -z "$INSTALL"; then
1705 if test "${ac_cv_path_install+set}" = set; then
1706   echo $ECHO_N "(cached) $ECHO_C" >&6
1707 else
1708   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1709 for as_dir in $PATH
1710 do
1711   IFS=$as_save_IFS
1712   test -z "$as_dir" && as_dir=.
1713   # Account for people who put trailing slashes in PATH elements.
1714 case $as_dir/ in
1715   ./ | .// | /cC/* | \
1716   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1717   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1718   /usr/ucb/* ) ;;
1719   *)
1720     # OSF1 and SCO ODT 3.0 have their own names for install.
1721     # Don't use installbsd from OSF since it installs stuff as root
1722     # by default.
1723     for ac_prog in ginstall scoinst install; do
1724       for ac_exec_ext in '' $ac_executable_extensions; do
1725         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1726           if test $ac_prog = install &&
1727             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1728             # AIX install.  It has an incompatible calling convention.
1729             :
1730           elif test $ac_prog = install &&
1731             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1732             # program-specific install script used by HP pwplus--don't use.
1733             :
1734           else
1735             rm -rf conftest.one conftest.two conftest.dir
1736             echo one > conftest.one
1737             echo two > conftest.two
1738             mkdir conftest.dir
1739             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1740               test -s conftest.one && test -s conftest.two &&
1741               test -s conftest.dir/conftest.one &&
1742               test -s conftest.dir/conftest.two
1743             then
1744               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1745               break 3
1746             fi
1747           fi
1748         fi
1749       done
1750     done
1751     ;;
1752 esac
1753 done
1754
1755 rm -rf conftest.one conftest.two conftest.dir
1756
1757 fi
1758   if test "${ac_cv_path_install+set}" = set; then
1759     INSTALL=$ac_cv_path_install
1760   else
1761     # As a last resort, use the slow shell script.  Don't cache a
1762     # value for INSTALL within a source directory, because that will
1763     # break other packages using the cache if that directory is
1764     # removed, or if the value is a relative name.
1765     INSTALL=$ac_install_sh
1766   fi
1767 fi
1768 echo "$as_me:$LINENO: result: $INSTALL" >&5
1769 echo "${ECHO_T}$INSTALL" >&6
1770
1771 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1772 # It thinks the first close brace ends the variable substitution.
1773 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1774
1775 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1776
1777 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1778
1779 echo "$as_me:$LINENO: checking whether ln works" >&5
1780 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1781 if test "${acx_cv_prog_LN+set}" = set; then
1782   echo $ECHO_N "(cached) $ECHO_C" >&6
1783 else
1784   rm -f conftestdata_t
1785 echo >conftestdata_f
1786 if ln conftestdata_f conftestdata_t 2>/dev/null
1787 then
1788   acx_cv_prog_LN=ln
1789 else
1790   acx_cv_prog_LN=no
1791 fi
1792 rm -f conftestdata_f conftestdata_t
1793
1794 fi
1795 if test $acx_cv_prog_LN = no; then
1796   LN="cp"
1797   echo "$as_me:$LINENO: result: no, using $LN" >&5
1798 echo "${ECHO_T}no, using $LN" >&6
1799 else
1800   LN="$acx_cv_prog_LN"
1801   echo "$as_me:$LINENO: result: yes" >&5
1802 echo "${ECHO_T}yes" >&6
1803 fi
1804
1805 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1806 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1807 LN_S=$as_ln_s
1808 if test "$LN_S" = "ln -s"; then
1809   echo "$as_me:$LINENO: result: yes" >&5
1810 echo "${ECHO_T}yes" >&6
1811 else
1812   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1813 echo "${ECHO_T}no, using $LN_S" >&6
1814 fi
1815
1816
1817 ### we might need to use some other shell than /bin/sh for running subshells
1818 ### If we are on Windows, search for the shell.  This will permit people
1819 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1820 ### without also having to set CONFIG_SHELL.  This code will work when
1821 ### using bash, which sets OSTYPE.
1822 case "${OSTYPE}" in
1823 *win32*)
1824   if test x${CONFIG_SHELL} = x ; then
1825     if test ! -f /bin/sh ; then
1826       if test x${SHELL} != x && test -f ${SHELL} ; then
1827         CONFIG_SHELL=${SHELL}
1828         export CONFIG_SHELL
1829       else
1830         for prog in sh sh.exe bash bash.exe; do
1831           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1832           for dir in $PATH; do
1833             test -z "$dir" && dir=.
1834             if test -f $dir/$prog; then
1835               CONFIG_SHELL=$dir/$prog
1836               export CONFIG_SHELL
1837               break
1838             fi
1839           done
1840           IFS="$save_ifs"
1841           test -n "${CONFIG_SHELL}" && break
1842         done
1843       fi
1844     fi
1845   fi
1846   ;;
1847 esac
1848
1849 config_shell=${CONFIG_SHELL-/bin/sh}
1850
1851 moveifchange=${srcdir}/move-if-change
1852
1853 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1854
1855 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1856 # a relative path.
1857 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1858   INSTALL="${srcpwd}/install-sh -c"
1859 fi
1860
1861 # Set srcdir to "." if that's what it is.
1862 # This is important for multilib support.
1863 pwd=`${PWDCMD-pwd}`
1864 if test "${pwd}" = "${srcpwd}" ; then
1865   srcdir=.
1866 fi
1867
1868 topsrcdir=$srcpwd
1869
1870 extra_host_args=
1871
1872 ### To add a new directory to the tree, first choose whether it is a target
1873 ### or a host dependent tool.  Then put it into the appropriate list
1874 ### (library or tools, host or target), doing a dependency sort.
1875
1876 # Subdirs will be configured in the order listed in build_configdirs,
1877 # configdirs, or target_configdirs; see the serialization section below.
1878
1879 # Dependency sorting is only needed when *configuration* must be done in
1880 # a particular order.  In all cases a dependency should be specified in
1881 # the Makefile, whether or not it's implicitly specified here.
1882
1883 # Double entries in build_configdirs, configdirs, or target_configdirs may
1884 # cause circular dependencies and break everything horribly.
1885
1886 # these library is used by various programs built for the build
1887 # environment
1888 #
1889 build_libs="build-libiberty"
1890
1891 # these tools are built for the build environment
1892 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1893
1894 # these libraries are used by various programs built for the host environment
1895 #
1896 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1897
1898 # these tools are built for the host environment
1899 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1900 # know that we are building the simulator.
1901 # binutils, gas and ld appear in that order because it makes sense to run
1902 # "make check" in that particular order.
1903 # If --enable-gold is used, "gold" will replace "ld".
1904 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc 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"
1905
1906 # libgcj represents the runtime libraries only used by gcj.
1907 libgcj="target-libffi \
1908         target-zlib \
1909         target-qthreads \
1910         target-libjava"
1911
1912 # these libraries are built for the target environment, and are built after
1913 # the host libraries and the host tools (which may be a cross compiler)
1914 #
1915 target_libraries="target-libgcc \
1916                 target-libiberty \
1917                 target-libgloss \
1918                 target-newlib \
1919                 target-libgomp \
1920                 target-libstdc++-v3 \
1921                 target-libmudflap \
1922                 target-libssp \
1923                 target-libgfortran \
1924                 target-boehm-gc \
1925                 ${libgcj} \
1926                 target-libobjc \
1927                 target-libada"
1928
1929 # these tools are built using the target libraries, and are intended to
1930 # run only in the target environment
1931 #
1932 # note: any program that *uses* libraries that are in the "target_libraries"
1933 # list belongs in this list.  those programs are also very likely
1934 # candidates for the "native_only" list which follows
1935 #
1936 target_tools="target-examples target-groff target-gperf target-rda"
1937
1938 ################################################################################
1939
1940 ## All tools belong in one of the four categories, and are assigned above
1941 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1942 ## is important because configure will choke if they ever get through.
1943 ## ${configdirs} is directories we build using the host tools.
1944 ## ${target_configdirs} is directories we build using the target tools.
1945 configdirs=`echo ${host_libs} ${host_tools}`
1946 target_configdirs=`echo ${target_libraries} ${target_tools}`
1947 build_configdirs=`echo ${build_libs} ${build_tools}`
1948
1949
1950
1951 ################################################################################
1952
1953 srcname="gnu development package"
1954
1955 # This gets set non-empty for some net releases of packages.
1956 appdirs=""
1957
1958 # Define is_cross_compiler to save on calls to 'test'.
1959 is_cross_compiler=
1960 if test x"${host}" = x"${target}" ; then
1961   is_cross_compiler=no
1962 else
1963   is_cross_compiler=yes
1964 fi
1965
1966 # Find the build and target subdir names.
1967
1968 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1969 # have matching libraries, they should use host libraries: Makefile.tpl
1970 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1971 # However, they still use the build modules, because the corresponding
1972 # host modules (e.g. bison) are only built for the host when bootstrap
1973 # finishes. So:
1974 # - build_subdir is where we find build modules, and never changes.
1975 # - build_libsubdir is where we find build libraries, and can be overridden.
1976
1977 # Prefix 'build-' so this never conflicts with target_subdir.
1978 build_subdir="build-${build_noncanonical}"
1979
1980 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1981 if test "${with_build_libsubdir+set}" = set; then
1982   withval="$with_build_libsubdir"
1983   build_libsubdir="$withval"
1984 else
1985   build_libsubdir="$build_subdir"
1986 fi;
1987 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1988 if ( test $srcdir = . && test -d gcc ) \
1989    || test -d $srcdir/../host-${host_noncanonical}; then
1990   host_subdir="host-${host_noncanonical}"
1991 else
1992   host_subdir=.
1993 fi
1994 # No prefix.
1995 target_subdir=${target_noncanonical}
1996
1997
1998 # Skipdirs are removed silently.
1999 skipdirs=
2000 # Noconfigdirs are removed loudly.
2001 noconfigdirs=""
2002
2003 use_gnu_ld=
2004 # Make sure we don't let GNU ld be added if we didn't want it.
2005 if test x$with_gnu_ld = xno ; then
2006   use_gnu_ld=no
2007   noconfigdirs="$noconfigdirs ld gold"
2008 fi
2009
2010 use_gnu_as=
2011 # Make sure we don't let GNU as be added if we didn't want it.
2012 if test x$with_gnu_as = xno ; then
2013   use_gnu_as=no
2014   noconfigdirs="$noconfigdirs gas"
2015 fi
2016
2017 # some tools are so dependent upon X11 that if we're not building with X,
2018 # it's not even worth trying to configure, much less build, that tool.
2019
2020 case ${with_x} in
2021   yes | "") ;; # the default value for this tree is that X11 is available
2022   no)
2023     skipdirs="${skipdirs} tk itcl libgui"
2024     # We won't be able to build gdbtk without X.
2025     enable_gdbtk=no
2026     ;;
2027   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2028 esac
2029
2030 # Some tools are only suitable for building in a "native" situation.
2031 # Remove these if host!=target.
2032 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"
2033
2034 # Similarly, some are only suitable for cross toolchains.
2035 # Remove these if host=target.
2036 cross_only="target-libgloss target-newlib target-opcodes"
2037
2038 case $is_cross_compiler in
2039   no) skipdirs="${skipdirs} ${cross_only}" ;;
2040   yes) skipdirs="${skipdirs} ${native_only}" ;;
2041 esac
2042
2043 # If both --with-headers and --with-libs are specified, default to
2044 # --without-newlib.
2045 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2046    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2047   if test x"${with_newlib}" = x ; then
2048     with_newlib=no
2049   fi
2050 fi
2051
2052 # Recognize --with-newlib/--without-newlib.
2053 case ${with_newlib} in
2054   no) skipdirs="${skipdirs} target-newlib" ;;
2055   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2056 esac
2057
2058 # Handle --enable-gold.
2059
2060 # Check whether --enable-gold or --disable-gold was given.
2061 if test "${enable_gold+set}" = set; then
2062   enableval="$enable_gold"
2063   ENABLE_GOLD=$enableval
2064 else
2065   ENABLE_GOLD=no
2066 fi;
2067 if test "${ENABLE_GOLD}" = "yes"; then
2068   # Check for ELF target.
2069   is_elf=no
2070   case "${target}" in
2071     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2072     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2073     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2074       case "${target}" in
2075         *-*-linux*aout* | *-*-linux*oldld*)
2076           ;;
2077         *)
2078           is_elf=yes
2079           ;;
2080       esac
2081   esac
2082
2083   if test "$is_elf" = "yes"; then
2084     # Check for target supported by gold.
2085     case "${target}" in
2086       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2087         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2088         ;;
2089     esac
2090   fi
2091 fi
2092
2093 # Configure extra directories which are host specific
2094
2095 case "${host}" in
2096   *-cygwin*)
2097     configdirs="$configdirs libtermcap" ;;
2098 esac
2099
2100 # A target can indicate whether a language isn't supported for some reason.
2101 # Only spaces may be used in this macro; not newlines or tabs.
2102 unsupported_languages=
2103
2104 # Remove more programs from consideration, based on the host or
2105 # target this usually means that a port of the program doesn't
2106 # exist yet.
2107
2108 case "${host}" in
2109   hppa*64*-*-*)
2110     noconfigdirs="$noconfigdirs byacc"
2111     ;;
2112   i[3456789]86-*-vsta)
2113     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2114     ;;
2115   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2116     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2117     ;;
2118   x86_64-*-mingw*)
2119     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2120     ;;
2121   i[3456789]86-*-mingw32*)
2122     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2123     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2124     ;;
2125   i[3456789]86-*-beos*)
2126     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2127     ;;
2128   *-*-cygwin*)
2129     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2130     ;;
2131   *-*-netbsd*)
2132     noconfigdirs="$noconfigdirs rcs"
2133     ;;
2134   ppc*-*-pe)
2135     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2136     ;;
2137   powerpc-*-beos*)
2138     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2139     ;;
2140 esac
2141
2142
2143 # Check whether --enable-libada or --disable-libada was given.
2144 if test "${enable_libada+set}" = set; then
2145   enableval="$enable_libada"
2146   ENABLE_LIBADA=$enableval
2147 else
2148   ENABLE_LIBADA=yes
2149 fi;
2150 if test "${ENABLE_LIBADA}" != "yes" ; then
2151   noconfigdirs="$noconfigdirs gnattools"
2152 fi
2153
2154 # Check whether --enable-libssp or --disable-libssp was given.
2155 if test "${enable_libssp+set}" = set; then
2156   enableval="$enable_libssp"
2157   ENABLE_LIBSSP=$enableval
2158 else
2159   ENABLE_LIBSSP=yes
2160 fi;
2161
2162 # Save it here so that, even in case of --enable-libgcj, if the Java
2163 # front-end isn't enabled, we still get libgcj disabled.
2164 libgcj_saved=$libgcj
2165 case $enable_libgcj in
2166 yes)
2167   # If we reset it here, it won't get added to noconfigdirs in the
2168   # target-specific build rules, so it will be forcibly enabled
2169   # (unless the Java language itself isn't enabled).
2170   libgcj=
2171   ;;
2172 no)
2173   # Make sure we get it printed in the list of not supported target libs.
2174   noconfigdirs="$noconfigdirs ${libgcj}"
2175   ;;
2176 esac
2177
2178
2179 # Disable libmudflap on some systems.
2180 if test x$enable_libmudflap = x ; then
2181     case "${target}" in
2182     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2183         # Enable libmudflap by default in GNU and friends.
2184         ;;
2185     *-*-freebsd*)
2186         # Enable libmudflap by default in FreeBSD.
2187         ;;
2188     *)
2189         # Disable it by default everywhere else.
2190         noconfigdirs="$noconfigdirs target-libmudflap"
2191         ;;
2192     esac
2193 fi
2194
2195 # Disable libgomp on non POSIX hosted systems.
2196 if test x$enable_libgomp = x ; then
2197     # Enable libgomp by default on hosted POSIX systems.
2198     case "${target}" in
2199     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2200         ;;
2201     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2202         ;;
2203     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2204         ;;
2205     *-*-darwin* | *-*-aix*)
2206         ;;
2207     *)
2208         noconfigdirs="$noconfigdirs target-libgomp"
2209         ;;
2210     esac
2211 fi
2212
2213 # Default libgloss CPU subdirectory.
2214 libgloss_dir="$target_cpu"
2215
2216 case "${target}" in
2217   *-*-chorusos)
2218     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2219     ;;
2220   powerpc-*-darwin*)
2221     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2222     noconfigdirs="$noconfigdirs sim target-rda"
2223     ;;
2224   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2225     noconfigdirs="$noconfigdirs ld gas gprof"
2226     noconfigdirs="$noconfigdirs sim target-rda"
2227     ;;
2228   *-*-darwin*)
2229     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2230     noconfigdirs="$noconfigdirs sim target-rda"
2231     noconfigdirs="$noconfigdirs ${libgcj}"
2232     ;;
2233   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2234     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2235     ;;
2236   *-*-freebsd*)
2237     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2238     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2239         && test -f /usr/local/include/gmp.h; then
2240       with_gmp=/usr/local
2241     fi
2242
2243     # Skip some stuff that's unsupported on some FreeBSD configurations.
2244     case "${target}" in
2245       i*86-*-*) ;;
2246       alpha*-*-*) ;;
2247       *)
2248         noconfigdirs="$noconfigdirs ${libgcj}"
2249         ;;
2250     esac
2251     ;;
2252   *-*-kaos*)
2253     # Remove unsupported stuff on all kaOS configurations.
2254     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2255     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2256     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2257     noconfigdirs="$noconfigdirs target-libgloss"
2258     ;;
2259   *-*-netbsd*)
2260     # Skip some stuff on all NetBSD configurations.
2261     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2262
2263     # Skip some stuff that's unsupported on some NetBSD configurations.
2264     case "${target}" in
2265       i*86-*-netbsdelf*) ;;
2266       arm*-*-netbsdelf*) ;;
2267       *)
2268         noconfigdirs="$noconfigdirs ${libgcj}"
2269         ;;
2270     esac
2271     ;;
2272   *-*-netware*)
2273     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2274     ;;
2275   *-*-rtems*)
2276     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2277     ;;
2278     # The tpf target doesn't support gdb yet.
2279   *-*-tpf*)
2280     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2281     ;;
2282   *-*-uclinux*)
2283     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2284     ;;
2285   *-*-vxworks*)
2286     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2287     ;;
2288   alpha*-dec-osf*)
2289     # ld works, but does not support shared libraries.
2290     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2291     # gas doesn't generate exception information.
2292     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2293     ;;
2294   alpha*-*-*vms*)
2295     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2296     ;;
2297   alpha*-*-linux*)
2298     # newlib is not 64 bit ready
2299     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2300     ;;
2301   alpha*-*-*)
2302     # newlib is not 64 bit ready
2303     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2304     ;;
2305   am33_2.0-*-linux*)
2306     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2307     ;;
2308   sh-*-linux*)
2309     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2310     ;;
2311   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2312     noconfigdirs="$noconfigdirs ${libgcj}"
2313     noconfigdirs="$noconfigdirs target-examples"
2314     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2315     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2316     noconfigdirs="$noconfigdirs expect dejagnu"
2317     # the C++ libraries don't build on top of CE's C libraries
2318     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2319     noconfigdirs="$noconfigdirs target-newlib"
2320     case "${host}" in
2321       *-*-cygwin*) ;; # keep gdb and readline
2322       *) noconfigdirs="$noconfigdirs gdb readline"
2323          ;;
2324     esac
2325     libgloss_dir=wince
2326     ;;
2327   arc-*-*)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   arm-semi-aof )
2331     ;;
2332   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2333     noconfigdirs="$noconfigdirs ${libgcj}"
2334     libgloss_dir=arm
2335     ;;
2336   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2337     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2338     libgloss_dir=arm
2339     ;;
2340   arm*-*-linux-gnueabi)
2341     noconfigdirs="$noconfigdirs target-qthreads"
2342     case ${with_newlib} in
2343       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2344     esac
2345     libgloss_dir=arm
2346     ;;
2347   arm*-*-symbianelf*)
2348     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2349     libgloss_dir=arm
2350     ;;
2351   arm-*-pe*)
2352     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2353     ;;
2354   thumb-*-coff)
2355     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2356     ;;
2357   thumb-*-elf)
2358     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2359     ;;
2360   thumb-*-pe)
2361     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2362     ;;
2363   arm-*-riscix*)
2364     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2365     ;;
2366   avr-*-*)
2367     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2368     ;;
2369   bfin-*-*)
2370     noconfigdirs="$noconfigdirs gdb"
2371     if test x${is_cross_compiler} != xno ; then
2372       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2373     fi
2374     ;;
2375   c4x-*-* | tic4x-*-*)
2376     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2377     ;;
2378   c54x*-*-* | tic54x-*-*)
2379     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2380     ;;
2381   cr16-*-*)
2382     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2383     ;;
2384   cris-*-* | crisv32-*-*)
2385     unsupported_languages="$unsupported_languages java"
2386     case "${target}" in
2387       *-*-aout)
2388         unsupported_languages="$unsupported_languages fortran"
2389         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2390       *-*-elf)
2391         noconfigdirs="$noconfigdirs target-boehm-gc";;
2392       *-*-linux*)
2393         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2394       *)
2395         unsupported_languages="$unsupported_languages fortran"
2396         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2397     esac
2398     libgloss_dir=cris
2399     ;;
2400   crx-*-*)
2401     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2402     ;;
2403   d10v-*-*)
2404     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2405     ;;
2406   d30v-*-*)
2407     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2408     ;;
2409   ep9312-*-elf | ep9312-*-coff)
2410     libgloss_dir=arm
2411     ;;
2412   fr30-*-elf*)
2413     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2414     ;;
2415   frv-*-*)
2416     noconfigdirs="$noconfigdirs ${libgcj}"
2417     ;;
2418   moxie-*-*)
2419     noconfigdirs="$noconfigdirs ${libgcj}"
2420     noconfigdirs="$noconfigdirs gprof"
2421     ;;
2422   h8300*-*-*)
2423     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2424     ;;
2425   h8500-*-*)
2426     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2427     ;;
2428   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2429     ;;
2430   hppa*64*-*-linux* | parisc*64*-*-linux*)
2431     # In this case, it's because the hppa64-linux target is for
2432     # the kernel only at this point and has no libc, and thus no
2433     # headers, crt*.o, etc., all of which are needed by these.
2434     noconfigdirs="$noconfigdirs target-zlib"
2435     ;;
2436   parisc*-*-linux* | hppa*-*-linux*)
2437     ;;
2438   hppa*-*-*elf* | \
2439   hppa*-*-lites* | \
2440   hppa*-*-openbsd* | \
2441   hppa*64*-*-*)
2442     noconfigdirs="$noconfigdirs ${libgcj}"
2443     ;;
2444   hppa*-hp-hpux11*)
2445     noconfigdirs="$noconfigdirs ld shellutils"
2446     ;;
2447   hppa*-*-pro*)
2448     libgloss_dir=pa
2449     ;;
2450   hppa*-*-*)
2451     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2452     # build on HP-UX 10.20.
2453     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2454     ;;
2455   i960-*-*)
2456     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2457     ;;
2458   ia64*-*-elf*)
2459     # No gdb support yet.
2460     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2461     ;;
2462   ia64*-**-hpux*)
2463     # No gdb or ld support yet.
2464     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2465     ;;
2466   ia64*-*-*vms*)
2467     # No gdb or ld support yet.
2468     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2469     ;;
2470   i370-*-opened*)
2471     ;;
2472   i[3456789]86-*-coff | i[3456789]86-*-elf)
2473     noconfigdirs="$noconfigdirs ${libgcj}"
2474     libgloss_dir=i386
2475     ;;
2476   i[3456789]86-*-linux*)
2477     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2478     # not build java stuff by default.
2479     case "${target}" in
2480       *-*-*libc1*)
2481         noconfigdirs="$noconfigdirs ${libgcj}";;
2482     esac
2483
2484     # This section makes it possible to build newlib natively on linux.
2485     # If we are using a cross compiler then don't configure newlib.
2486     if test x${is_cross_compiler} != xno ; then
2487       noconfigdirs="$noconfigdirs target-newlib"
2488     fi
2489     noconfigdirs="$noconfigdirs target-libgloss"
2490     # If we are not using a cross compiler, do configure newlib.
2491     # Note however, that newlib will only be configured in this situation
2492     # if the --with-newlib option has been given, because otherwise
2493     # 'target-newlib' will appear in skipdirs.
2494     ;;
2495   i[3456789]86-*-mingw32*)
2496     target_configdirs="$target_configdirs target-winsup"
2497     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2498     ;;
2499   x86_64-*-mingw*)
2500     target_configdirs="$target_configdirs target-winsup"
2501     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2502     ;;
2503   *-*-cygwin*)
2504     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2505     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2506     # always build newlib if winsup directory is present.
2507     if test -d "$srcdir/winsup/cygwin"; then
2508       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2509     elif test -d "$srcdir/newlib"; then
2510       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2511     fi
2512     ;;
2513   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2514   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2515     ;;
2516   i[3456789]86-*-pe)
2517     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2518     ;;
2519   i[3456789]86-*-sco3.2v5*)
2520     # The linker does not yet know about weak symbols in COFF,
2521     # and is not configured to handle mixed ELF and COFF.
2522     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2523     ;;
2524   i[3456789]86-*-sco*)
2525     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2526     ;;
2527   i[3456789]86-*-solaris2*)
2528     noconfigdirs="$noconfigdirs target-libgloss"
2529     ;;
2530   i[3456789]86-*-sysv4*)
2531     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2532     ;;
2533   i[3456789]86-*-beos*)
2534     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2535     ;;
2536   i[3456789]86-*-rdos*)
2537     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2538     ;;
2539   m32r-*-*)
2540     noconfigdirs="$noconfigdirs ${libgcj}"
2541     ;;
2542   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2543     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2544     libgloss_dir=m68hc11
2545     ;;
2546   m68k-*-elf*)
2547     noconfigdirs="$noconfigdirs ${libgcj}"
2548     ;;
2549   m68k-*-coff*)
2550     noconfigdirs="$noconfigdirs ${libgcj}"
2551     ;;
2552   m68*-*-* | fido-*-*)
2553     libgloss_dir=m68k
2554     ;;
2555   mcore-*-pe*)
2556   # The EPOC C++ environment does not support exceptions or rtti,
2557   # and so building libstdc++-v3 tends not to always work.
2558     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2559     ;;
2560   mmix-*-*)
2561     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2562     unsupported_languages="$unsupported_languages fortran java"
2563     ;;
2564   mn10200-*-*)
2565     noconfigdirs="$noconfigdirs ${libgcj}"
2566     ;;
2567   mn10300-*-*)
2568     noconfigdirs="$noconfigdirs ${libgcj}"
2569     ;;
2570   mt-*-*)
2571     noconfigdirs="$noconfigdirs sim"
2572     ;;
2573   powerpc-*-aix*)
2574     # copied from rs6000-*-* entry
2575     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2576     ;;
2577   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2578     target_configdirs="$target_configdirs target-winsup"
2579     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2580     # always build newlib.
2581     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2582     ;;
2583     # This is temporary until we can link against shared libraries
2584   powerpcle-*-solaris*)
2585     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2586     libgloss_dir=rs6000
2587     ;;
2588   powerpc-*-beos*)
2589     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2590     ;;
2591   powerpc-*-eabi)
2592     noconfigdirs="$noconfigdirs ${libgcj}"
2593     libgloss_dir=rs6000
2594     ;;
2595   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2596     libgloss_dir=rs6000
2597     ;;
2598   rs6000-*-lynxos*)
2599     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2600     ;;
2601   rs6000-*-aix*)
2602     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2603     ;;
2604   rs6000-*-*)
2605     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2606     ;;
2607   m68k-apollo-*)
2608     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2609     ;;
2610   mips*-sde-elf*)
2611     skipdirs="$skipdirs target-libiberty"
2612     noconfigdirs="$noconfigdirs ${libgcj}"
2613     if test x$with_newlib = xyes; then
2614       noconfigdirs="$noconfigdirs gprof"
2615     fi
2616     libgloss_dir=mips
2617     ;;
2618   mips*-*-irix5*)
2619     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2620     ;;
2621   mips*-*-irix6*)
2622     # Linking libjava exceeds command-line length limits on at least
2623     # IRIX 6.2, but not on IRIX 6.5.
2624     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2625     # <oldham@codesourcery.com>
2626     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2627     ;;
2628   mips*-*-bsd*)
2629     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2630     ;;
2631   mips*-*-linux*)
2632     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2633     ;;
2634   mips*-*-*)
2635     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2636     libgloss_dir=mips
2637     ;;
2638   romp-*-*)
2639     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2640     ;;
2641   sh-*-* | sh64-*-*)
2642     case "${host}" in
2643       i[3456789]86-*-vsta) ;; # don't add gprof back in
2644       i[3456789]86-*-go32*) ;; # don't add gprof back in
2645       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2646       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2647     esac
2648     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2649     ;;
2650   sparclet-*-aout* | sparc86x-*-*)
2651     libgloss_dir=sparc
2652     ;;
2653   sparc-*-elf*)
2654     noconfigdirs="$noconfigdirs ${libgcj}"
2655     ;;
2656   sparc64-*-elf*)
2657     noconfigdirs="$noconfigdirs ${libgcj}"
2658     libgloss_dir=sparc
2659     ;;
2660   sparclite-*-*)
2661     noconfigdirs="$noconfigdirs ${libgcj}"
2662     libgloss_dir=sparc
2663     ;;
2664   sparc-*-sunos4*)
2665     noconfigdirs="$noconfigdirs ${libgcj}"
2666     if test x${is_cross_compiler} != xno ; then
2667            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2668     else
2669            use_gnu_ld=no
2670     fi
2671     ;;
2672   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2673     noconfigdirs="$noconfigdirs ${libgcj}"
2674     ;;
2675   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2676     ;;
2677   v810-*-*)
2678     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2679     ;;
2680   v850-*-*)
2681     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2682     ;;
2683   v850e-*-*)
2684     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2685     ;;
2686   v850ea-*-*)
2687     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2688     ;;
2689   vax-*-vms)
2690     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2691     ;;
2692   vax-*-*)
2693     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2694     ;;
2695   xtensa*-*-*)
2696     noconfigdirs="$noconfigdirs ${libgcj}"
2697     ;;
2698   ip2k-*-*)
2699     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2700     ;;
2701   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2702     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2703     ;;
2704   *-*-lynxos*)
2705     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2706     ;;
2707   *-*-*)
2708     noconfigdirs="$noconfigdirs ${libgcj}"
2709     ;;
2710 esac
2711
2712 # If we aren't building newlib, then don't build libgloss, since libgloss
2713 # depends upon some newlib header files.
2714 case "${noconfigdirs}" in
2715   *target-libgloss*) ;;
2716   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2717 esac
2718
2719 # Work in distributions that contain no compiler tools, like Autoconf.
2720 tentative_cc=""
2721 host_makefile_frag=/dev/null
2722 if test -d ${srcdir}/config ; then
2723 case "${host}" in
2724   m68k-hp-hpux*)
2725     # Avoid "too much defining" errors from HPUX compiler.
2726     tentative_cc="cc -Wp,-H256000"
2727     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2728     # If it's HP/UX ar, this should be harmless.
2729     RANLIB="ar ts"
2730     ;;
2731   m68k-apollo-sysv*)
2732     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2733     ;;
2734   m68k-apollo-bsd*)
2735     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2736     # chokes on bfd, the compiler won't let you assign integers to enums, and
2737     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2738     # the apollo compiler" (the preferred version of GCC could be called cc,
2739     # or whatever), but I'm not sure leaving CC as cc is any better...
2740     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2741     # Used to have BISON=yacc.
2742     tentative_cc=gcc
2743     ;;
2744   m88k-dg-dgux*)
2745     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2746     ;;
2747   m88k-harris-cxux*)
2748     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2749     tentative_cc="cc -Xa"
2750     host_makefile_frag="config/mh-cxux"
2751     ;;
2752   m88k-motorola-sysv*)
2753     ;;
2754   mips*-dec-ultrix*)
2755     tentative_cc="cc -Wf,-XNg1000"
2756     host_makefile_frag="config/mh-decstation"
2757     ;;
2758   mips*-nec-sysv4*)
2759     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2760     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2761     host_makefile_frag="config/mh-necv4"
2762     ;;
2763   mips*-sgi-irix4*)
2764     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2765     # environment.  Also bump switch table size so that cp-parse will
2766     # compile.  Bump string length limit so linker builds.
2767     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2768     ;;
2769   mips*-*-sysv4*)
2770     host_makefile_frag="config/mh-sysv4"
2771     ;;
2772   mips*-*-sysv*)
2773     # This is for a MIPS running RISC/os 4.52C.
2774
2775     # This is needed for GDB, but needs to be in the top-level make because
2776     # if a library is compiled with the bsd headers and gets linked with the
2777     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2778     # a different size).
2779     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2780     # known except to select the sysv environment.  Could we use /proc instead?
2781     # These "sysv environments" and "bsd environments" often end up being a pain.
2782     #
2783     # This is not part of CFLAGS because perhaps not all C compilers have this
2784     # option.
2785     tentative_cc="cc -systype sysv"
2786     ;;
2787   i370-ibm-opened*)
2788     tentative_cc="c89"
2789     ;;
2790   i[3456789]86-*-sysv5*)
2791     host_makefile_frag="config/mh-sysv5"
2792     ;;
2793   i[3456789]86-*-dgux*)
2794     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2795     host_makefile_frag="config/mh-dgux386"
2796     ;;
2797   i[3456789]86-ncr-sysv4.3*)
2798     # The MetaWare compiler will generate a copyright message unless you
2799     # turn it off by adding the -Hnocopyr flag.
2800     tentative_cc="cc -Hnocopyr"
2801     ;;
2802   i[3456789]86-ncr-sysv4*)
2803     # for an NCR 3000 (i486/SVR4) system.
2804     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2805     # This compiler not only emits obnoxious copyright messages every time
2806     # you run it, but it chokes and dies on a whole bunch of GNU source
2807     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2808     tentative_cc="/usr/ccs/ATT/cc"
2809     host_makefile_frag="config/mh-ncr3000"
2810     ;;
2811   i[3456789]86-*-sco3.2v5*)
2812     ;;
2813   i[3456789]86-*-sco*)
2814     # The native C compiler botches some simple uses of const.  Unfortunately,
2815     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2816     tentative_cc="cc -Dconst="
2817     host_makefile_frag="config/mh-sco"
2818     ;;
2819   i[3456789]86-*-udk*)
2820     host_makefile_frag="config/mh-sysv5"
2821     ;;
2822   i[3456789]86-*-solaris2*)
2823     host_makefile_frag="config/mh-sysv4"
2824     ;;
2825   i[3456789]86-*-msdosdjgpp*)
2826     host_makefile_frag="config/mh-djgpp"
2827     ;;
2828   *-cygwin*)
2829
2830 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2831 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2832 echo a >cygwin-cat-check
2833 if test `cat cygwin-cat-check` == a ; then
2834   rm cygwin-cat-check
2835   echo "$as_me:$LINENO: result: yes" >&5
2836 echo "${ECHO_T}yes" >&6
2837 else
2838   rm cygwin-cat-check
2839   echo "$as_me:$LINENO: result: no" >&5
2840 echo "${ECHO_T}no" >&6
2841   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2842   Please either mount the build directory in binary mode or run the following
2843   commands before running any configure script:
2844 set -o igncr
2845 export SHELLOPTS
2846   " >&5
2847 echo "$as_me: error: The cat command does not ignore carriage return characters.
2848   Please either mount the build directory in binary mode or run the following
2849   commands before running any configure script:
2850 set -o igncr
2851 export SHELLOPTS
2852   " >&2;}
2853    { (exit 1); exit 1; }; }
2854 fi
2855
2856     host_makefile_frag="config/mh-cygwin"
2857     ;;
2858   *-mingw*)
2859     host_makefile_frag="config/mh-mingw"
2860     ;;
2861   *-interix*)
2862     host_makefile_frag="config/mh-interix"
2863     ;;
2864   vax-*-ultrix2*)
2865     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2866     tentative_cc=gcc
2867     ;;
2868   *-*-solaris2*)
2869     host_makefile_frag="config/mh-solaris"
2870     ;;
2871   m68k-sun-sunos*)
2872     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2873     # without overflowing the jump tables (-J says to use a 32 bit table)
2874     tentative_cc="cc -J"
2875     ;;
2876   hppa*-hp-hpux10*)
2877     tentative_cc="cc -Wp,-H256000"
2878     host_makefile_frag="config/mh-pa-hpux10"
2879     ;;
2880   hppa*-hp-hpux* | hppa*-*-hiux*)
2881     tentative_cc="cc -Wp,-H256000"
2882     host_makefile_frag="config/mh-pa"
2883     ;;
2884   hppa*-*)
2885     host_makefile_frag="config/mh-pa"
2886     ;;
2887   *-hp-hpux* | *-*-hiux*)
2888     tentative_cc="cc -Wp,-H256000"
2889     ;;
2890   rs6000-*-lynxos*)
2891     # /bin/cc is less than useful for our purposes.  Always use GCC
2892     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2893     host_makefile_frag="config/mh-lynxrs6k"
2894     ;;
2895   powerpc-*-darwin*)
2896     host_makefile_frag="config/mh-ppc-darwin"
2897     ;;
2898   powerpc-*-aix*)
2899     host_makefile_frag="config/mh-ppc-aix"
2900     ;;
2901   rs6000-*-aix*)
2902     host_makefile_frag="config/mh-ppc-aix"
2903     ;;
2904   *-*-lynxos*)
2905     # /bin/cc is less than useful for our purposes.  Always use GCC
2906     tentative_cc="/bin/gcc"
2907     ;;
2908   *-*-sysv4*)
2909     host_makefile_frag="config/mh-sysv4"
2910     ;;
2911   # This is placed last to prevent interfering with the cases above.
2912   i[3456789]86-*-*)
2913     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2914     host_makefile_frag="config/mh-x86omitfp"
2915     ;;
2916 esac
2917 fi
2918
2919 # If we aren't going to be using gcc, see if we can extract a definition
2920 # of CC from the fragment.
2921 # Actually, use the 'pre-extracted' version above.
2922 if test -z "${CC}" && test "${build}" = "${host}" ; then
2923   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2924   found=
2925   for dir in $PATH; do
2926     test -z "$dir" && dir=.
2927     if test -f $dir/gcc; then
2928       found=yes
2929       break
2930     fi
2931   done
2932   IFS="$save_ifs"
2933   if test -z "${found}" && test -n "${tentative_cc}" ; then
2934     CC=$tentative_cc
2935   fi
2936 fi
2937
2938 if test "${build}" != "${host}" ; then
2939   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2940   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2941   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2942   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2943   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2944   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2945   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2946   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2947   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2948   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2949   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2950   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2951 else
2952   AR_FOR_BUILD="\$(AR)"
2953   AS_FOR_BUILD="\$(AS)"
2954   CC_FOR_BUILD="\$(CC)"
2955   CXX_FOR_BUILD="\$(CXX)"
2956   GCJ_FOR_BUILD="\$(GCJ)"
2957   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2958   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2959   LD_FOR_BUILD="\$(LD)"
2960   NM_FOR_BUILD="\$(NM)"
2961   RANLIB_FOR_BUILD="\$(RANLIB)"
2962   WINDRES_FOR_BUILD="\$(WINDRES)"
2963   WINDMC_FOR_BUILD="\$(WINDMC)"
2964 fi
2965
2966 ac_ext=c
2967 ac_cpp='$CPP $CPPFLAGS'
2968 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2969 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2970 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2971 if test -n "$ac_tool_prefix"; then
2972   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2973 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2974 echo "$as_me:$LINENO: checking for $ac_word" >&5
2975 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2976 if test "${ac_cv_prog_CC+set}" = set; then
2977   echo $ECHO_N "(cached) $ECHO_C" >&6
2978 else
2979   if test -n "$CC"; then
2980   ac_cv_prog_CC="$CC" # Let the user override the test.
2981 else
2982 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2983 for as_dir in $PATH
2984 do
2985   IFS=$as_save_IFS
2986   test -z "$as_dir" && as_dir=.
2987   for ac_exec_ext in '' $ac_executable_extensions; do
2988   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2989     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2990     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2991     break 2
2992   fi
2993 done
2994 done
2995
2996 fi
2997 fi
2998 CC=$ac_cv_prog_CC
2999 if test -n "$CC"; then
3000   echo "$as_me:$LINENO: result: $CC" >&5
3001 echo "${ECHO_T}$CC" >&6
3002 else
3003   echo "$as_me:$LINENO: result: no" >&5
3004 echo "${ECHO_T}no" >&6
3005 fi
3006
3007 fi
3008 if test -z "$ac_cv_prog_CC"; then
3009   ac_ct_CC=$CC
3010   # Extract the first word of "gcc", so it can be a program name with args.
3011 set dummy gcc; ac_word=$2
3012 echo "$as_me:$LINENO: checking for $ac_word" >&5
3013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3014 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3015   echo $ECHO_N "(cached) $ECHO_C" >&6
3016 else
3017   if test -n "$ac_ct_CC"; then
3018   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3019 else
3020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3021 for as_dir in $PATH
3022 do
3023   IFS=$as_save_IFS
3024   test -z "$as_dir" && as_dir=.
3025   for ac_exec_ext in '' $ac_executable_extensions; do
3026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3027     ac_cv_prog_ac_ct_CC="gcc"
3028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3029     break 2
3030   fi
3031 done
3032 done
3033
3034 fi
3035 fi
3036 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3037 if test -n "$ac_ct_CC"; then
3038   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3039 echo "${ECHO_T}$ac_ct_CC" >&6
3040 else
3041   echo "$as_me:$LINENO: result: no" >&5
3042 echo "${ECHO_T}no" >&6
3043 fi
3044
3045   CC=$ac_ct_CC
3046 else
3047   CC="$ac_cv_prog_CC"
3048 fi
3049
3050 if test -z "$CC"; then
3051   if test -n "$ac_tool_prefix"; then
3052   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3053 set dummy ${ac_tool_prefix}cc; ac_word=$2
3054 echo "$as_me:$LINENO: checking for $ac_word" >&5
3055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3056 if test "${ac_cv_prog_CC+set}" = set; then
3057   echo $ECHO_N "(cached) $ECHO_C" >&6
3058 else
3059   if test -n "$CC"; then
3060   ac_cv_prog_CC="$CC" # Let the user override the test.
3061 else
3062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3063 for as_dir in $PATH
3064 do
3065   IFS=$as_save_IFS
3066   test -z "$as_dir" && as_dir=.
3067   for ac_exec_ext in '' $ac_executable_extensions; do
3068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3069     ac_cv_prog_CC="${ac_tool_prefix}cc"
3070     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3071     break 2
3072   fi
3073 done
3074 done
3075
3076 fi
3077 fi
3078 CC=$ac_cv_prog_CC
3079 if test -n "$CC"; then
3080   echo "$as_me:$LINENO: result: $CC" >&5
3081 echo "${ECHO_T}$CC" >&6
3082 else
3083   echo "$as_me:$LINENO: result: no" >&5
3084 echo "${ECHO_T}no" >&6
3085 fi
3086
3087 fi
3088 if test -z "$ac_cv_prog_CC"; then
3089   ac_ct_CC=$CC
3090   # Extract the first word of "cc", so it can be a program name with args.
3091 set dummy cc; ac_word=$2
3092 echo "$as_me:$LINENO: checking for $ac_word" >&5
3093 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3094 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3095   echo $ECHO_N "(cached) $ECHO_C" >&6
3096 else
3097   if test -n "$ac_ct_CC"; then
3098   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3099 else
3100 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3101 for as_dir in $PATH
3102 do
3103   IFS=$as_save_IFS
3104   test -z "$as_dir" && as_dir=.
3105   for ac_exec_ext in '' $ac_executable_extensions; do
3106   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3107     ac_cv_prog_ac_ct_CC="cc"
3108     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3109     break 2
3110   fi
3111 done
3112 done
3113
3114 fi
3115 fi
3116 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3117 if test -n "$ac_ct_CC"; then
3118   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3119 echo "${ECHO_T}$ac_ct_CC" >&6
3120 else
3121   echo "$as_me:$LINENO: result: no" >&5
3122 echo "${ECHO_T}no" >&6
3123 fi
3124
3125   CC=$ac_ct_CC
3126 else
3127   CC="$ac_cv_prog_CC"
3128 fi
3129
3130 fi
3131 if test -z "$CC"; then
3132   # Extract the first word of "cc", so it can be a program name with args.
3133 set dummy cc; ac_word=$2
3134 echo "$as_me:$LINENO: checking for $ac_word" >&5
3135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3136 if test "${ac_cv_prog_CC+set}" = set; then
3137   echo $ECHO_N "(cached) $ECHO_C" >&6
3138 else
3139   if test -n "$CC"; then
3140   ac_cv_prog_CC="$CC" # Let the user override the test.
3141 else
3142   ac_prog_rejected=no
3143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3144 for as_dir in $PATH
3145 do
3146   IFS=$as_save_IFS
3147   test -z "$as_dir" && as_dir=.
3148   for ac_exec_ext in '' $ac_executable_extensions; do
3149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3150     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3151        ac_prog_rejected=yes
3152        continue
3153      fi
3154     ac_cv_prog_CC="cc"
3155     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3156     break 2
3157   fi
3158 done
3159 done
3160
3161 if test $ac_prog_rejected = yes; then
3162   # We found a bogon in the path, so make sure we never use it.
3163   set dummy $ac_cv_prog_CC
3164   shift
3165   if test $# != 0; then
3166     # We chose a different compiler from the bogus one.
3167     # However, it has the same basename, so the bogon will be chosen
3168     # first if we set CC to just the basename; use the full file name.
3169     shift
3170     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3171   fi
3172 fi
3173 fi
3174 fi
3175 CC=$ac_cv_prog_CC
3176 if test -n "$CC"; then
3177   echo "$as_me:$LINENO: result: $CC" >&5
3178 echo "${ECHO_T}$CC" >&6
3179 else
3180   echo "$as_me:$LINENO: result: no" >&5
3181 echo "${ECHO_T}no" >&6
3182 fi
3183
3184 fi
3185 if test -z "$CC"; then
3186   if test -n "$ac_tool_prefix"; then
3187   for ac_prog in cl
3188   do
3189     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3190 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3191 echo "$as_me:$LINENO: checking for $ac_word" >&5
3192 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3193 if test "${ac_cv_prog_CC+set}" = set; then
3194   echo $ECHO_N "(cached) $ECHO_C" >&6
3195 else
3196   if test -n "$CC"; then
3197   ac_cv_prog_CC="$CC" # Let the user override the test.
3198 else
3199 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3200 for as_dir in $PATH
3201 do
3202   IFS=$as_save_IFS
3203   test -z "$as_dir" && as_dir=.
3204   for ac_exec_ext in '' $ac_executable_extensions; do
3205   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3206     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3207     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3208     break 2
3209   fi
3210 done
3211 done
3212
3213 fi
3214 fi
3215 CC=$ac_cv_prog_CC
3216 if test -n "$CC"; then
3217   echo "$as_me:$LINENO: result: $CC" >&5
3218 echo "${ECHO_T}$CC" >&6
3219 else
3220   echo "$as_me:$LINENO: result: no" >&5
3221 echo "${ECHO_T}no" >&6
3222 fi
3223
3224     test -n "$CC" && break
3225   done
3226 fi
3227 if test -z "$CC"; then
3228   ac_ct_CC=$CC
3229   for ac_prog in cl
3230 do
3231   # Extract the first word of "$ac_prog", so it can be a program name with args.
3232 set dummy $ac_prog; ac_word=$2
3233 echo "$as_me:$LINENO: checking for $ac_word" >&5
3234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3235 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3236   echo $ECHO_N "(cached) $ECHO_C" >&6
3237 else
3238   if test -n "$ac_ct_CC"; then
3239   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3240 else
3241 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3242 for as_dir in $PATH
3243 do
3244   IFS=$as_save_IFS
3245   test -z "$as_dir" && as_dir=.
3246   for ac_exec_ext in '' $ac_executable_extensions; do
3247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3248     ac_cv_prog_ac_ct_CC="$ac_prog"
3249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3250     break 2
3251   fi
3252 done
3253 done
3254
3255 fi
3256 fi
3257 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3258 if test -n "$ac_ct_CC"; then
3259   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3260 echo "${ECHO_T}$ac_ct_CC" >&6
3261 else
3262   echo "$as_me:$LINENO: result: no" >&5
3263 echo "${ECHO_T}no" >&6
3264 fi
3265
3266   test -n "$ac_ct_CC" && break
3267 done
3268
3269   CC=$ac_ct_CC
3270 fi
3271
3272 fi
3273
3274
3275 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3276 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3277 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3278 See \`config.log' for more details." >&5
3279 echo "$as_me: error: no acceptable C compiler found in \$PATH
3280 See \`config.log' for more details." >&2;}
3281    { (exit 1); exit 1; }; }; }
3282
3283 # Provide some information about the compiler.
3284 echo "$as_me:$LINENO:" \
3285      "checking for C compiler version" >&5
3286 ac_compiler=`set X $ac_compile; echo $2`
3287 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3288   (eval $ac_compiler --version </dev/null >&5) 2>&5
3289   ac_status=$?
3290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3291   (exit $ac_status); }
3292 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3293   (eval $ac_compiler -v </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
3303 cat >conftest.$ac_ext <<_ACEOF
3304 /* confdefs.h.  */
3305 _ACEOF
3306 cat confdefs.h >>conftest.$ac_ext
3307 cat >>conftest.$ac_ext <<_ACEOF
3308 /* end confdefs.h.  */
3309
3310 int
3311 main ()
3312 {
3313
3314   ;
3315   return 0;
3316 }
3317 _ACEOF
3318 ac_clean_files_save=$ac_clean_files
3319 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3320 # Try to create an executable without -o first, disregard a.out.
3321 # It will help us diagnose broken compilers, and finding out an intuition
3322 # of exeext.
3323 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3324 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3325 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3326 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3327   (eval $ac_link_default) 2>&5
3328   ac_status=$?
3329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3330   (exit $ac_status); }; then
3331   # Find the output, starting from the most likely.  This scheme is
3332 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3333 # resort.
3334
3335 # Be careful to initialize this variable, since it used to be cached.
3336 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3337 ac_cv_exeext=
3338 # b.out is created by i960 compilers.
3339 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3340 do
3341   test -f "$ac_file" || continue
3342   case $ac_file in
3343     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3344         ;;
3345     conftest.$ac_ext )
3346         # This is the source file.
3347         ;;
3348     [ab].out )
3349         # We found the default executable, but exeext='' is most
3350         # certainly right.
3351         break;;
3352     *.* )
3353         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3354         # FIXME: I believe we export ac_cv_exeext for Libtool,
3355         # but it would be cool to find out if it's true.  Does anybody
3356         # maintain Libtool? --akim.
3357         export ac_cv_exeext
3358         break;;
3359     * )
3360         break;;
3361   esac
3362 done
3363 else
3364   echo "$as_me: failed program was:" >&5
3365 sed 's/^/| /' conftest.$ac_ext >&5
3366
3367 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3368 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3369 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3370 See \`config.log' for more details." >&5
3371 echo "$as_me: error: C compiler cannot create executables
3372 See \`config.log' for more details." >&2;}
3373    { (exit 77); exit 77; }; }; }
3374 fi
3375
3376 ac_exeext=$ac_cv_exeext
3377 echo "$as_me:$LINENO: result: $ac_file" >&5
3378 echo "${ECHO_T}$ac_file" >&6
3379
3380 # Check the compiler produces executables we can run.  If not, either
3381 # the compiler is broken, or we cross compile.
3382 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3383 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3384 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3385 # If not cross compiling, check that we can run a simple program.
3386 if test "$cross_compiling" != yes; then
3387   if { ac_try='./$ac_file'
3388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3389   (eval $ac_try) 2>&5
3390   ac_status=$?
3391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3392   (exit $ac_status); }; }; then
3393     cross_compiling=no
3394   else
3395     if test "$cross_compiling" = maybe; then
3396         cross_compiling=yes
3397     else
3398         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3399 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3400 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3401 If you meant to cross compile, use \`--host'.
3402 See \`config.log' for more details." >&5
3403 echo "$as_me: error: cannot run C compiled programs.
3404 If you meant to cross compile, use \`--host'.
3405 See \`config.log' for more details." >&2;}
3406    { (exit 1); exit 1; }; }; }
3407     fi
3408   fi
3409 fi
3410 echo "$as_me:$LINENO: result: yes" >&5
3411 echo "${ECHO_T}yes" >&6
3412
3413 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3414 ac_clean_files=$ac_clean_files_save
3415 # Check the compiler produces executables we can run.  If not, either
3416 # the compiler is broken, or we cross compile.
3417 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3418 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3419 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3420 echo "${ECHO_T}$cross_compiling" >&6
3421
3422 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3423 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3424 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3425   (eval $ac_link) 2>&5
3426   ac_status=$?
3427   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3428   (exit $ac_status); }; then
3429   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3430 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3431 # work properly (i.e., refer to `conftest.exe'), while it won't with
3432 # `rm'.
3433 for ac_file in conftest.exe conftest conftest.*; do
3434   test -f "$ac_file" || continue
3435   case $ac_file in
3436     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3437     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3438           export ac_cv_exeext
3439           break;;
3440     * ) break;;
3441   esac
3442 done
3443 else
3444   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3445 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3446 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3447 See \`config.log' for more details." >&5
3448 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3449 See \`config.log' for more details." >&2;}
3450    { (exit 1); exit 1; }; }; }
3451 fi
3452
3453 rm -f conftest$ac_cv_exeext
3454 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3455 echo "${ECHO_T}$ac_cv_exeext" >&6
3456
3457 rm -f conftest.$ac_ext
3458 EXEEXT=$ac_cv_exeext
3459 ac_exeext=$EXEEXT
3460 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3461 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3462 if test "${ac_cv_objext+set}" = set; then
3463   echo $ECHO_N "(cached) $ECHO_C" >&6
3464 else
3465   cat >conftest.$ac_ext <<_ACEOF
3466 /* confdefs.h.  */
3467 _ACEOF
3468 cat confdefs.h >>conftest.$ac_ext
3469 cat >>conftest.$ac_ext <<_ACEOF
3470 /* end confdefs.h.  */
3471
3472 int
3473 main ()
3474 {
3475
3476   ;
3477   return 0;
3478 }
3479 _ACEOF
3480 rm -f conftest.o conftest.obj
3481 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3482   (eval $ac_compile) 2>&5
3483   ac_status=$?
3484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3485   (exit $ac_status); }; then
3486   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3487   case $ac_file in
3488     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3489     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3490        break;;
3491   esac
3492 done
3493 else
3494   echo "$as_me: failed program was:" >&5
3495 sed 's/^/| /' conftest.$ac_ext >&5
3496
3497 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3498 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3499 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3500 See \`config.log' for more details." >&5
3501 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3502 See \`config.log' for more details." >&2;}
3503    { (exit 1); exit 1; }; }; }
3504 fi
3505
3506 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3507 fi
3508 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3509 echo "${ECHO_T}$ac_cv_objext" >&6
3510 OBJEXT=$ac_cv_objext
3511 ac_objext=$OBJEXT
3512 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3513 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3514 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3515   echo $ECHO_N "(cached) $ECHO_C" >&6
3516 else
3517   cat >conftest.$ac_ext <<_ACEOF
3518 /* confdefs.h.  */
3519 _ACEOF
3520 cat confdefs.h >>conftest.$ac_ext
3521 cat >>conftest.$ac_ext <<_ACEOF
3522 /* end confdefs.h.  */
3523
3524 int
3525 main ()
3526 {
3527 #ifndef __GNUC__
3528        choke me
3529 #endif
3530
3531   ;
3532   return 0;
3533 }
3534 _ACEOF
3535 rm -f conftest.$ac_objext
3536 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3537   (eval $ac_compile) 2>conftest.er1
3538   ac_status=$?
3539   grep -v '^ *+' conftest.er1 >conftest.err
3540   rm -f conftest.er1
3541   cat conftest.err >&5
3542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3543   (exit $ac_status); } &&
3544          { ac_try='test -z "$ac_c_werror_flag"
3545                          || test ! -s conftest.err'
3546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3547   (eval $ac_try) 2>&5
3548   ac_status=$?
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); }; } &&
3551          { ac_try='test -s conftest.$ac_objext'
3552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3553   (eval $ac_try) 2>&5
3554   ac_status=$?
3555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556   (exit $ac_status); }; }; then
3557   ac_compiler_gnu=yes
3558 else
3559   echo "$as_me: failed program was:" >&5
3560 sed 's/^/| /' conftest.$ac_ext >&5
3561
3562 ac_compiler_gnu=no
3563 fi
3564 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3565 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3566
3567 fi
3568 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3569 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3570 GCC=`test $ac_compiler_gnu = yes && echo yes`
3571 ac_test_CFLAGS=${CFLAGS+set}
3572 ac_save_CFLAGS=$CFLAGS
3573 CFLAGS="-g"
3574 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3575 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3576 if test "${ac_cv_prog_cc_g+set}" = set; then
3577   echo $ECHO_N "(cached) $ECHO_C" >&6
3578 else
3579   cat >conftest.$ac_ext <<_ACEOF
3580 /* confdefs.h.  */
3581 _ACEOF
3582 cat confdefs.h >>conftest.$ac_ext
3583 cat >>conftest.$ac_ext <<_ACEOF
3584 /* end confdefs.h.  */
3585
3586 int
3587 main ()
3588 {
3589
3590   ;
3591   return 0;
3592 }
3593 _ACEOF
3594 rm -f conftest.$ac_objext
3595 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3596   (eval $ac_compile) 2>conftest.er1
3597   ac_status=$?
3598   grep -v '^ *+' conftest.er1 >conftest.err
3599   rm -f conftest.er1
3600   cat conftest.err >&5
3601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3602   (exit $ac_status); } &&
3603          { ac_try='test -z "$ac_c_werror_flag"
3604                          || test ! -s conftest.err'
3605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3606   (eval $ac_try) 2>&5
3607   ac_status=$?
3608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3609   (exit $ac_status); }; } &&
3610          { ac_try='test -s conftest.$ac_objext'
3611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3612   (eval $ac_try) 2>&5
3613   ac_status=$?
3614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3615   (exit $ac_status); }; }; then
3616   ac_cv_prog_cc_g=yes
3617 else
3618   echo "$as_me: failed program was:" >&5
3619 sed 's/^/| /' conftest.$ac_ext >&5
3620
3621 ac_cv_prog_cc_g=no
3622 fi
3623 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3624 fi
3625 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3626 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3627 if test "$ac_test_CFLAGS" = set; then
3628   CFLAGS=$ac_save_CFLAGS
3629 elif test $ac_cv_prog_cc_g = yes; then
3630   if test "$GCC" = yes; then
3631     CFLAGS="-g -O2"
3632   else
3633     CFLAGS="-g"
3634   fi
3635 else
3636   if test "$GCC" = yes; then
3637     CFLAGS="-O2"
3638   else
3639     CFLAGS=
3640   fi
3641 fi
3642 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3643 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3644 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3645   echo $ECHO_N "(cached) $ECHO_C" >&6
3646 else
3647   ac_cv_prog_cc_stdc=no
3648 ac_save_CC=$CC
3649 cat >conftest.$ac_ext <<_ACEOF
3650 /* confdefs.h.  */
3651 _ACEOF
3652 cat confdefs.h >>conftest.$ac_ext
3653 cat >>conftest.$ac_ext <<_ACEOF
3654 /* end confdefs.h.  */
3655 #include <stdarg.h>
3656 #include <stdio.h>
3657 #include <sys/types.h>
3658 #include <sys/stat.h>
3659 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3660 struct buf { int x; };
3661 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3662 static char *e (p, i)
3663      char **p;
3664      int i;
3665 {
3666   return p[i];
3667 }
3668 static char *f (char * (*g) (char **, int), char **p, ...)
3669 {
3670   char *s;
3671   va_list v;
3672   va_start (v,p);
3673   s = g (p, va_arg (v,int));
3674   va_end (v);
3675   return s;
3676 }
3677
3678 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3679    function prototypes and stuff, but not '\xHH' hex character constants.
3680    These don't provoke an error unfortunately, instead are silently treated
3681    as 'x'.  The following induces an error, until -std1 is added to get
3682    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3683    array size at least.  It's necessary to write '\x00'==0 to get something
3684    that's true only with -std1.  */
3685 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3686
3687 int test (int i, double x);
3688 struct s1 {int (*f) (int a);};
3689 struct s2 {int (*f) (double a);};
3690 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3691 int argc;
3692 char **argv;
3693 int
3694 main ()
3695 {
3696 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3697   ;
3698   return 0;
3699 }
3700 _ACEOF
3701 # Don't try gcc -ansi; that turns off useful extensions and
3702 # breaks some systems' header files.
3703 # AIX                   -qlanglvl=ansi
3704 # Ultrix and OSF/1      -std1
3705 # HP-UX 10.20 and later -Ae
3706 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3707 # SVR4                  -Xc -D__EXTENSIONS__
3708 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3709 do
3710   CC="$ac_save_CC $ac_arg"
3711   rm -f conftest.$ac_objext
3712 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3713   (eval $ac_compile) 2>conftest.er1
3714   ac_status=$?
3715   grep -v '^ *+' conftest.er1 >conftest.err
3716   rm -f conftest.er1
3717   cat conftest.err >&5
3718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3719   (exit $ac_status); } &&
3720          { ac_try='test -z "$ac_c_werror_flag"
3721                          || test ! -s conftest.err'
3722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3723   (eval $ac_try) 2>&5
3724   ac_status=$?
3725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3726   (exit $ac_status); }; } &&
3727          { ac_try='test -s conftest.$ac_objext'
3728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3729   (eval $ac_try) 2>&5
3730   ac_status=$?
3731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3732   (exit $ac_status); }; }; then
3733   ac_cv_prog_cc_stdc=$ac_arg
3734 break
3735 else
3736   echo "$as_me: failed program was:" >&5
3737 sed 's/^/| /' conftest.$ac_ext >&5
3738
3739 fi
3740 rm -f conftest.err conftest.$ac_objext
3741 done
3742 rm -f conftest.$ac_ext conftest.$ac_objext
3743 CC=$ac_save_CC
3744
3745 fi
3746
3747 case "x$ac_cv_prog_cc_stdc" in
3748   x|xno)
3749     echo "$as_me:$LINENO: result: none needed" >&5
3750 echo "${ECHO_T}none needed" >&6 ;;
3751   *)
3752     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3753 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3754     CC="$CC $ac_cv_prog_cc_stdc" ;;
3755 esac
3756
3757 # Some people use a C++ compiler to compile C.  Since we use `exit',
3758 # in C++ we need to declare it.  In case someone uses the same compiler
3759 # for both compiling C and C++ we need to have the C++ compiler decide
3760 # the declaration of exit, since it's the most demanding environment.
3761 cat >conftest.$ac_ext <<_ACEOF
3762 #ifndef __cplusplus
3763   choke me
3764 #endif
3765 _ACEOF
3766 rm -f conftest.$ac_objext
3767 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3768   (eval $ac_compile) 2>conftest.er1
3769   ac_status=$?
3770   grep -v '^ *+' conftest.er1 >conftest.err
3771   rm -f conftest.er1
3772   cat conftest.err >&5
3773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3774   (exit $ac_status); } &&
3775          { ac_try='test -z "$ac_c_werror_flag"
3776                          || test ! -s conftest.err'
3777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3778   (eval $ac_try) 2>&5
3779   ac_status=$?
3780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3781   (exit $ac_status); }; } &&
3782          { ac_try='test -s conftest.$ac_objext'
3783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3784   (eval $ac_try) 2>&5
3785   ac_status=$?
3786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787   (exit $ac_status); }; }; then
3788   for ac_declaration in \
3789    '' \
3790    'extern "C" void std::exit (int) throw (); using std::exit;' \
3791    'extern "C" void std::exit (int); using std::exit;' \
3792    'extern "C" void exit (int) throw ();' \
3793    'extern "C" void exit (int);' \
3794    'void exit (int);'
3795 do
3796   cat >conftest.$ac_ext <<_ACEOF
3797 /* confdefs.h.  */
3798 _ACEOF
3799 cat confdefs.h >>conftest.$ac_ext
3800 cat >>conftest.$ac_ext <<_ACEOF
3801 /* end confdefs.h.  */
3802 $ac_declaration
3803 #include <stdlib.h>
3804 int
3805 main ()
3806 {
3807 exit (42);
3808   ;
3809   return 0;
3810 }
3811 _ACEOF
3812 rm -f conftest.$ac_objext
3813 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3814   (eval $ac_compile) 2>conftest.er1
3815   ac_status=$?
3816   grep -v '^ *+' conftest.er1 >conftest.err
3817   rm -f conftest.er1
3818   cat conftest.err >&5
3819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3820   (exit $ac_status); } &&
3821          { ac_try='test -z "$ac_c_werror_flag"
3822                          || test ! -s conftest.err'
3823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3824   (eval $ac_try) 2>&5
3825   ac_status=$?
3826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3827   (exit $ac_status); }; } &&
3828          { ac_try='test -s conftest.$ac_objext'
3829   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3830   (eval $ac_try) 2>&5
3831   ac_status=$?
3832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3833   (exit $ac_status); }; }; then
3834   :
3835 else
3836   echo "$as_me: failed program was:" >&5
3837 sed 's/^/| /' conftest.$ac_ext >&5
3838
3839 continue
3840 fi
3841 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3842   cat >conftest.$ac_ext <<_ACEOF
3843 /* confdefs.h.  */
3844 _ACEOF
3845 cat confdefs.h >>conftest.$ac_ext
3846 cat >>conftest.$ac_ext <<_ACEOF
3847 /* end confdefs.h.  */
3848 $ac_declaration
3849 int
3850 main ()
3851 {
3852 exit (42);
3853   ;
3854   return 0;
3855 }
3856 _ACEOF
3857 rm -f conftest.$ac_objext
3858 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3859   (eval $ac_compile) 2>conftest.er1
3860   ac_status=$?
3861   grep -v '^ *+' conftest.er1 >conftest.err
3862   rm -f conftest.er1
3863   cat conftest.err >&5
3864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3865   (exit $ac_status); } &&
3866          { ac_try='test -z "$ac_c_werror_flag"
3867                          || test ! -s conftest.err'
3868   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3869   (eval $ac_try) 2>&5
3870   ac_status=$?
3871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3872   (exit $ac_status); }; } &&
3873          { ac_try='test -s conftest.$ac_objext'
3874   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3875   (eval $ac_try) 2>&5
3876   ac_status=$?
3877   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3878   (exit $ac_status); }; }; then
3879   break
3880 else
3881   echo "$as_me: failed program was:" >&5
3882 sed 's/^/| /' conftest.$ac_ext >&5
3883
3884 fi
3885 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3886 done
3887 rm -f conftest*
3888 if test -n "$ac_declaration"; then
3889   echo '#ifdef __cplusplus' >>confdefs.h
3890   echo $ac_declaration      >>confdefs.h
3891   echo '#endif'             >>confdefs.h
3892 fi
3893
3894 else
3895   echo "$as_me: failed program was:" >&5
3896 sed 's/^/| /' conftest.$ac_ext >&5
3897
3898 fi
3899 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3900 ac_ext=c
3901 ac_cpp='$CPP $CPPFLAGS'
3902 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3903 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3904 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3905
3906 ac_ext=cc
3907 ac_cpp='$CXXCPP $CPPFLAGS'
3908 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3909 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3911 if test -n "$ac_tool_prefix"; then
3912   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3913   do
3914     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3915 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3916 echo "$as_me:$LINENO: checking for $ac_word" >&5
3917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3918 if test "${ac_cv_prog_CXX+set}" = set; then
3919   echo $ECHO_N "(cached) $ECHO_C" >&6
3920 else
3921   if test -n "$CXX"; then
3922   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3923 else
3924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3925 for as_dir in $PATH
3926 do
3927   IFS=$as_save_IFS
3928   test -z "$as_dir" && as_dir=.
3929   for ac_exec_ext in '' $ac_executable_extensions; do
3930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3931     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3933     break 2
3934   fi
3935 done
3936 done
3937
3938 fi
3939 fi
3940 CXX=$ac_cv_prog_CXX
3941 if test -n "$CXX"; then
3942   echo "$as_me:$LINENO: result: $CXX" >&5
3943 echo "${ECHO_T}$CXX" >&6
3944 else
3945   echo "$as_me:$LINENO: result: no" >&5
3946 echo "${ECHO_T}no" >&6
3947 fi
3948
3949     test -n "$CXX" && break
3950   done
3951 fi
3952 if test -z "$CXX"; then
3953   ac_ct_CXX=$CXX
3954   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3955 do
3956   # Extract the first word of "$ac_prog", so it can be a program name with args.
3957 set dummy $ac_prog; ac_word=$2
3958 echo "$as_me:$LINENO: checking for $ac_word" >&5
3959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3960 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3961   echo $ECHO_N "(cached) $ECHO_C" >&6
3962 else
3963   if test -n "$ac_ct_CXX"; then
3964   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3965 else
3966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3967 for as_dir in $PATH
3968 do
3969   IFS=$as_save_IFS
3970   test -z "$as_dir" && as_dir=.
3971   for ac_exec_ext in '' $ac_executable_extensions; do
3972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3973     ac_cv_prog_ac_ct_CXX="$ac_prog"
3974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3975     break 2
3976   fi
3977 done
3978 done
3979
3980 fi
3981 fi
3982 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3983 if test -n "$ac_ct_CXX"; then
3984   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3985 echo "${ECHO_T}$ac_ct_CXX" >&6
3986 else
3987   echo "$as_me:$LINENO: result: no" >&5
3988 echo "${ECHO_T}no" >&6
3989 fi
3990
3991   test -n "$ac_ct_CXX" && break
3992 done
3993 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3994
3995   CXX=$ac_ct_CXX
3996 fi
3997
3998
3999 # Provide some information about the compiler.
4000 echo "$as_me:$LINENO:" \
4001      "checking for C++ compiler version" >&5
4002 ac_compiler=`set X $ac_compile; echo $2`
4003 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4004   (eval $ac_compiler --version </dev/null >&5) 2>&5
4005   ac_status=$?
4006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007   (exit $ac_status); }
4008 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4009   (eval $ac_compiler -v </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
4019 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4020 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4021 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4022   echo $ECHO_N "(cached) $ECHO_C" >&6
4023 else
4024   cat >conftest.$ac_ext <<_ACEOF
4025 /* confdefs.h.  */
4026 _ACEOF
4027 cat confdefs.h >>conftest.$ac_ext
4028 cat >>conftest.$ac_ext <<_ACEOF
4029 /* end confdefs.h.  */
4030
4031 int
4032 main ()
4033 {
4034 #ifndef __GNUC__
4035        choke me
4036 #endif
4037
4038   ;
4039   return 0;
4040 }
4041 _ACEOF
4042 rm -f conftest.$ac_objext
4043 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4044   (eval $ac_compile) 2>conftest.er1
4045   ac_status=$?
4046   grep -v '^ *+' conftest.er1 >conftest.err
4047   rm -f conftest.er1
4048   cat conftest.err >&5
4049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4050   (exit $ac_status); } &&
4051          { ac_try='test -z "$ac_cxx_werror_flag"
4052                          || test ! -s conftest.err'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; } &&
4058          { ac_try='test -s conftest.$ac_objext'
4059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4060   (eval $ac_try) 2>&5
4061   ac_status=$?
4062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4063   (exit $ac_status); }; }; then
4064   ac_compiler_gnu=yes
4065 else
4066   echo "$as_me: failed program was:" >&5
4067 sed 's/^/| /' conftest.$ac_ext >&5
4068
4069 ac_compiler_gnu=no
4070 fi
4071 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4072 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4073
4074 fi
4075 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4076 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4077 GXX=`test $ac_compiler_gnu = yes && echo yes`
4078 ac_test_CXXFLAGS=${CXXFLAGS+set}
4079 ac_save_CXXFLAGS=$CXXFLAGS
4080 CXXFLAGS="-g"
4081 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4082 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4083 if test "${ac_cv_prog_cxx_g+set}" = set; then
4084   echo $ECHO_N "(cached) $ECHO_C" >&6
4085 else
4086   cat >conftest.$ac_ext <<_ACEOF
4087 /* confdefs.h.  */
4088 _ACEOF
4089 cat confdefs.h >>conftest.$ac_ext
4090 cat >>conftest.$ac_ext <<_ACEOF
4091 /* end confdefs.h.  */
4092
4093 int
4094 main ()
4095 {
4096
4097   ;
4098   return 0;
4099 }
4100 _ACEOF
4101 rm -f conftest.$ac_objext
4102 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4103   (eval $ac_compile) 2>conftest.er1
4104   ac_status=$?
4105   grep -v '^ *+' conftest.er1 >conftest.err
4106   rm -f conftest.er1
4107   cat conftest.err >&5
4108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4109   (exit $ac_status); } &&
4110          { ac_try='test -z "$ac_cxx_werror_flag"
4111                          || test ! -s conftest.err'
4112   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4113   (eval $ac_try) 2>&5
4114   ac_status=$?
4115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4116   (exit $ac_status); }; } &&
4117          { ac_try='test -s conftest.$ac_objext'
4118   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4119   (eval $ac_try) 2>&5
4120   ac_status=$?
4121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4122   (exit $ac_status); }; }; then
4123   ac_cv_prog_cxx_g=yes
4124 else
4125   echo "$as_me: failed program was:" >&5
4126 sed 's/^/| /' conftest.$ac_ext >&5
4127
4128 ac_cv_prog_cxx_g=no
4129 fi
4130 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4131 fi
4132 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4133 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4134 if test "$ac_test_CXXFLAGS" = set; then
4135   CXXFLAGS=$ac_save_CXXFLAGS
4136 elif test $ac_cv_prog_cxx_g = yes; then
4137   if test "$GXX" = yes; then
4138     CXXFLAGS="-g -O2"
4139   else
4140     CXXFLAGS="-g"
4141   fi
4142 else
4143   if test "$GXX" = yes; then
4144     CXXFLAGS="-O2"
4145   else
4146     CXXFLAGS=
4147   fi
4148 fi
4149 for ac_declaration in \
4150    '' \
4151    'extern "C" void std::exit (int) throw (); using std::exit;' \
4152    'extern "C" void std::exit (int); using std::exit;' \
4153    'extern "C" void exit (int) throw ();' \
4154    'extern "C" void exit (int);' \
4155    'void exit (int);'
4156 do
4157   cat >conftest.$ac_ext <<_ACEOF
4158 /* confdefs.h.  */
4159 _ACEOF
4160 cat confdefs.h >>conftest.$ac_ext
4161 cat >>conftest.$ac_ext <<_ACEOF
4162 /* end confdefs.h.  */
4163 $ac_declaration
4164 #include <stdlib.h>
4165 int
4166 main ()
4167 {
4168 exit (42);
4169   ;
4170   return 0;
4171 }
4172 _ACEOF
4173 rm -f conftest.$ac_objext
4174 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4175   (eval $ac_compile) 2>conftest.er1
4176   ac_status=$?
4177   grep -v '^ *+' conftest.er1 >conftest.err
4178   rm -f conftest.er1
4179   cat conftest.err >&5
4180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4181   (exit $ac_status); } &&
4182          { ac_try='test -z "$ac_cxx_werror_flag"
4183                          || test ! -s conftest.err'
4184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4185   (eval $ac_try) 2>&5
4186   ac_status=$?
4187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4188   (exit $ac_status); }; } &&
4189          { ac_try='test -s conftest.$ac_objext'
4190   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4191   (eval $ac_try) 2>&5
4192   ac_status=$?
4193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4194   (exit $ac_status); }; }; then
4195   :
4196 else
4197   echo "$as_me: failed program was:" >&5
4198 sed 's/^/| /' conftest.$ac_ext >&5
4199
4200 continue
4201 fi
4202 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4203   cat >conftest.$ac_ext <<_ACEOF
4204 /* confdefs.h.  */
4205 _ACEOF
4206 cat confdefs.h >>conftest.$ac_ext
4207 cat >>conftest.$ac_ext <<_ACEOF
4208 /* end confdefs.h.  */
4209 $ac_declaration
4210 int
4211 main ()
4212 {
4213 exit (42);
4214   ;
4215   return 0;
4216 }
4217 _ACEOF
4218 rm -f conftest.$ac_objext
4219 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4220   (eval $ac_compile) 2>conftest.er1
4221   ac_status=$?
4222   grep -v '^ *+' conftest.er1 >conftest.err
4223   rm -f conftest.er1
4224   cat conftest.err >&5
4225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4226   (exit $ac_status); } &&
4227          { ac_try='test -z "$ac_cxx_werror_flag"
4228                          || test ! -s conftest.err'
4229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4230   (eval $ac_try) 2>&5
4231   ac_status=$?
4232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4233   (exit $ac_status); }; } &&
4234          { ac_try='test -s conftest.$ac_objext'
4235   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4236   (eval $ac_try) 2>&5
4237   ac_status=$?
4238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4239   (exit $ac_status); }; }; then
4240   break
4241 else
4242   echo "$as_me: failed program was:" >&5
4243 sed 's/^/| /' conftest.$ac_ext >&5
4244
4245 fi
4246 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4247 done
4248 rm -f conftest*
4249 if test -n "$ac_declaration"; then
4250   echo '#ifdef __cplusplus' >>confdefs.h
4251   echo $ac_declaration      >>confdefs.h
4252   echo '#endif'             >>confdefs.h
4253 fi
4254
4255 ac_ext=c
4256 ac_cpp='$CPP $CPPFLAGS'
4257 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4258 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4259 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4260
4261
4262 # We must set the default linker to the linker used by gcc for the correct
4263 # operation of libtool.  If LD is not defined and we are using gcc, try to
4264 # set the LD default to the ld used by gcc.
4265 if test -z "$LD"; then
4266   if test "$GCC" = yes; then
4267     case $build in
4268     *-*-mingw*)
4269       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4270     *)
4271       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4272     esac
4273     case $gcc_prog_ld in
4274     # Accept absolute paths.
4275     [\\/]* | [A-Za-z]:[\\/]*)
4276       LD="$gcc_prog_ld" ;;
4277     esac
4278   fi
4279 fi
4280
4281
4282
4283
4284 if test -n "$ac_tool_prefix"; then
4285   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4286 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4287 echo "$as_me:$LINENO: checking for $ac_word" >&5
4288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4289 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4290   echo $ECHO_N "(cached) $ECHO_C" >&6
4291 else
4292   if test -n "$GNATBIND"; then
4293   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4294 else
4295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4296 for as_dir in $PATH
4297 do
4298   IFS=$as_save_IFS
4299   test -z "$as_dir" && as_dir=.
4300   for ac_exec_ext in '' $ac_executable_extensions; do
4301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4302     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4304     break 2
4305   fi
4306 done
4307 done
4308
4309 fi
4310 fi
4311 GNATBIND=$ac_cv_prog_GNATBIND
4312 if test -n "$GNATBIND"; then
4313   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4314 echo "${ECHO_T}$GNATBIND" >&6
4315 else
4316   echo "$as_me:$LINENO: result: no" >&5
4317 echo "${ECHO_T}no" >&6
4318 fi
4319
4320 fi
4321 if test -z "$ac_cv_prog_GNATBIND"; then
4322   ac_ct_GNATBIND=$GNATBIND
4323   # Extract the first word of "gnatbind", so it can be a program name with args.
4324 set dummy gnatbind; ac_word=$2
4325 echo "$as_me:$LINENO: checking for $ac_word" >&5
4326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4327 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4328   echo $ECHO_N "(cached) $ECHO_C" >&6
4329 else
4330   if test -n "$ac_ct_GNATBIND"; then
4331   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4332 else
4333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4334 for as_dir in $PATH
4335 do
4336   IFS=$as_save_IFS
4337   test -z "$as_dir" && as_dir=.
4338   for ac_exec_ext in '' $ac_executable_extensions; do
4339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4340     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4342     break 2
4343   fi
4344 done
4345 done
4346
4347   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4348 fi
4349 fi
4350 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4351 if test -n "$ac_ct_GNATBIND"; then
4352   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4353 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4354 else
4355   echo "$as_me:$LINENO: result: no" >&5
4356 echo "${ECHO_T}no" >&6
4357 fi
4358
4359   GNATBIND=$ac_ct_GNATBIND
4360 else
4361   GNATBIND="$ac_cv_prog_GNATBIND"
4362 fi
4363
4364 if test -n "$ac_tool_prefix"; then
4365   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4366 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4367 echo "$as_me:$LINENO: checking for $ac_word" >&5
4368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4369 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4370   echo $ECHO_N "(cached) $ECHO_C" >&6
4371 else
4372   if test -n "$GNATMAKE"; then
4373   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4374 else
4375 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4376 for as_dir in $PATH
4377 do
4378   IFS=$as_save_IFS
4379   test -z "$as_dir" && as_dir=.
4380   for ac_exec_ext in '' $ac_executable_extensions; do
4381   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4382     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4383     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4384     break 2
4385   fi
4386 done
4387 done
4388
4389 fi
4390 fi
4391 GNATMAKE=$ac_cv_prog_GNATMAKE
4392 if test -n "$GNATMAKE"; then
4393   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4394 echo "${ECHO_T}$GNATMAKE" >&6
4395 else
4396   echo "$as_me:$LINENO: result: no" >&5
4397 echo "${ECHO_T}no" >&6
4398 fi
4399
4400 fi
4401 if test -z "$ac_cv_prog_GNATMAKE"; then
4402   ac_ct_GNATMAKE=$GNATMAKE
4403   # Extract the first word of "gnatmake", so it can be a program name with args.
4404 set dummy gnatmake; ac_word=$2
4405 echo "$as_me:$LINENO: checking for $ac_word" >&5
4406 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4407 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4408   echo $ECHO_N "(cached) $ECHO_C" >&6
4409 else
4410   if test -n "$ac_ct_GNATMAKE"; then
4411   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4412 else
4413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4414 for as_dir in $PATH
4415 do
4416   IFS=$as_save_IFS
4417   test -z "$as_dir" && as_dir=.
4418   for ac_exec_ext in '' $ac_executable_extensions; do
4419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4420     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4422     break 2
4423   fi
4424 done
4425 done
4426
4427   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4428 fi
4429 fi
4430 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4431 if test -n "$ac_ct_GNATMAKE"; then
4432   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4433 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4434 else
4435   echo "$as_me:$LINENO: result: no" >&5
4436 echo "${ECHO_T}no" >&6
4437 fi
4438
4439   GNATMAKE=$ac_ct_GNATMAKE
4440 else
4441   GNATMAKE="$ac_cv_prog_GNATMAKE"
4442 fi
4443
4444 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4445 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4446 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4447   echo $ECHO_N "(cached) $ECHO_C" >&6
4448 else
4449   cat >conftest.adb <<EOF
4450 procedure conftest is begin null; end conftest;
4451 EOF
4452 acx_cv_cc_gcc_supports_ada=no
4453 # There is a bug in old released versions of GCC which causes the
4454 # driver to exit successfully when the appropriate language module
4455 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4456 # Therefore we must check for the error message as well as an
4457 # unsuccessful exit.
4458 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4459 # given a .adb file, but produce no object file.  So we must check
4460 # if an object file was really produced to guard against this.
4461 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4462 if test x"$errors" = x && test -f conftest.$ac_objext; then
4463   acx_cv_cc_gcc_supports_ada=yes
4464 fi
4465 rm -f conftest.*
4466 fi
4467 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4468 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4469
4470 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4471   have_gnat=yes
4472 else
4473   have_gnat=no
4474 fi
4475
4476 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4477 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4478 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4479   echo $ECHO_N "(cached) $ECHO_C" >&6
4480 else
4481    echo abfoo >t1
4482   echo cdfoo >t2
4483   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4484   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4485     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4486       :
4487     else
4488       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4489     fi
4490   fi
4491   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4492     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4493       :
4494     else
4495       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4496     fi
4497   fi
4498   rm t1 t2
4499
4500 fi
4501 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4502 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4503 do_compare="$gcc_cv_prog_cmp_skip"
4504
4505
4506
4507 # Check for GMP, MPFR and MPC
4508 gmplibs="-lmpfr -lgmp"
4509 gmpinc=
4510 have_gmp=no
4511 mpclibs=-lmpc
4512 mpcinc=
4513 have_mpc=no
4514
4515 # Specify a location for mpc
4516 # check for this first so it ends up on the link line before mpfr.
4517
4518 # Check whether --with-mpc or --without-mpc was given.
4519 if test "${with_mpc+set}" = set; then
4520   withval="$with_mpc"
4521
4522 fi;
4523
4524 # Check whether --with-mpc_include or --without-mpc_include was given.
4525 if test "${with_mpc_include+set}" = set; then
4526   withval="$with_mpc_include"
4527
4528 fi;
4529
4530 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4531 if test "${with_mpc_lib+set}" = set; then
4532   withval="$with_mpc_lib"
4533
4534 fi;
4535
4536 if test "x$with_mpc" != x; then
4537   mpclibs="-L$with_mpc/lib -lmpc"
4538   mpcinc="-I$with_mpc/include $mpcinc"
4539 fi
4540 if test "x$with_mpc_include" != x; then
4541   mpcinc="-I$with_mpc_include $mpcinc"
4542 fi
4543 if test "x$with_mpc_lib" != x; then
4544   mpclibs="-L$with_mpc_lib -lmpc"
4545 fi
4546 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4547   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4548   mpcinc='-I$$s/mpc/src '"$mpcinc"
4549   # Do not test the mpc version.  Assume that it is sufficient, since
4550   # it is in the source tree, and the library has not been built yet
4551   # but it would be included on the link line in the version check below
4552   # hence making the test fail.
4553   have_mpc=yes
4554 fi
4555
4556 # Specify a location for mpfr
4557 # check for this first so it ends up on the link line before gmp.
4558
4559 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4560 if test "${with_mpfr_dir+set}" = set; then
4561   withval="$with_mpfr_dir"
4562   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4563 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4564 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4565 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4566    { (exit 1); exit 1; }; }
4567 fi;
4568
4569
4570 # Check whether --with-mpfr or --without-mpfr was given.
4571 if test "${with_mpfr+set}" = set; then
4572   withval="$with_mpfr"
4573
4574 fi;
4575
4576 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4577 if test "${with_mpfr_include+set}" = set; then
4578   withval="$with_mpfr_include"
4579
4580 fi;
4581
4582 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4583 if test "${with_mpfr_lib+set}" = set; then
4584   withval="$with_mpfr_lib"
4585
4586 fi;
4587
4588 if test "x$with_mpfr" != x; then
4589   gmplibs="-L$with_mpfr/lib $gmplibs"
4590   gmpinc="-I$with_mpfr/include"
4591 fi
4592 if test "x$with_mpfr_include" != x; then
4593   gmpinc="-I$with_mpfr_include"
4594 fi
4595 if test "x$with_mpfr_lib" != x; then
4596   gmplibs="-L$with_mpfr_lib $gmplibs"
4597 fi
4598 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4599   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4600   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4601   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4602   # Do not test the mpfr version.  Assume that it is sufficient, since
4603   # it is in the source tree, and the library has not been built yet
4604   # but it would be included on the link line in the version check below
4605   # hence making the test fail.
4606   have_gmp=yes
4607 fi
4608
4609 # Specify a location for gmp
4610
4611 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4612 if test "${with_gmp_dir+set}" = set; then
4613   withval="$with_gmp_dir"
4614   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4615 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4616 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4617 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4618    { (exit 1); exit 1; }; }
4619 fi;
4620
4621
4622 # Check whether --with-gmp or --without-gmp was given.
4623 if test "${with_gmp+set}" = set; then
4624   withval="$with_gmp"
4625
4626 fi;
4627
4628 # Check whether --with-gmp_include or --without-gmp_include was given.
4629 if test "${with_gmp_include+set}" = set; then
4630   withval="$with_gmp_include"
4631
4632 fi;
4633
4634 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4635 if test "${with_gmp_lib+set}" = set; then
4636   withval="$with_gmp_lib"
4637
4638 fi;
4639
4640
4641 if test "x$with_gmp" != x; then
4642   gmplibs="-L$with_gmp/lib $gmplibs"
4643   gmpinc="-I$with_gmp/include $gmpinc"
4644 fi
4645 if test "x$with_gmp_include" != x; then
4646   gmpinc="-I$with_gmp_include $gmpinc"
4647 fi
4648 if test "x$with_gmp_lib" != x; then
4649   gmplibs="-L$with_gmp_lib $gmplibs"
4650 fi
4651 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4652   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4653   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4654   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4655   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4656   # Do not test the gmp version.  Assume that it is sufficient, since
4657   # it is in the source tree, and the library has not been built yet
4658   # but it would be included on the link line in the version check below
4659   # hence making the test fail.
4660   have_gmp=yes
4661 fi
4662
4663 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4664   have_gmp=yes
4665   saved_CFLAGS="$CFLAGS"
4666   CFLAGS="$CFLAGS $gmpinc"
4667   # Check GMP actually works
4668   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4669 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4670
4671 cat >conftest.$ac_ext <<_ACEOF
4672 /* confdefs.h.  */
4673 _ACEOF
4674 cat confdefs.h >>conftest.$ac_ext
4675 cat >>conftest.$ac_ext <<_ACEOF
4676 /* end confdefs.h.  */
4677 #include "gmp.h"
4678 int
4679 main ()
4680 {
4681
4682   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4683   choke me
4684   #endif
4685
4686   ;
4687   return 0;
4688 }
4689 _ACEOF
4690 rm -f conftest.$ac_objext
4691 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4692   (eval $ac_compile) 2>conftest.er1
4693   ac_status=$?
4694   grep -v '^ *+' conftest.er1 >conftest.err
4695   rm -f conftest.er1
4696   cat conftest.err >&5
4697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698   (exit $ac_status); } &&
4699          { ac_try='test -z "$ac_c_werror_flag"
4700                          || test ! -s conftest.err'
4701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4702   (eval $ac_try) 2>&5
4703   ac_status=$?
4704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4705   (exit $ac_status); }; } &&
4706          { ac_try='test -s conftest.$ac_objext'
4707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4708   (eval $ac_try) 2>&5
4709   ac_status=$?
4710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4711   (exit $ac_status); }; }; then
4712   echo "$as_me:$LINENO: result: yes" >&5
4713 echo "${ECHO_T}yes" >&6
4714 else
4715   echo "$as_me: failed program was:" >&5
4716 sed 's/^/| /' conftest.$ac_ext >&5
4717
4718 echo "$as_me:$LINENO: result: no" >&5
4719 echo "${ECHO_T}no" >&6; have_gmp=no
4720 fi
4721 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4722
4723   # If we have GMP, check the MPFR version.
4724   if test x"$have_gmp" = xyes; then
4725         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4726 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4727     cat >conftest.$ac_ext <<_ACEOF
4728 /* confdefs.h.  */
4729 _ACEOF
4730 cat confdefs.h >>conftest.$ac_ext
4731 cat >>conftest.$ac_ext <<_ACEOF
4732 /* end confdefs.h.  */
4733 #include <gmp.h>
4734     #include <mpfr.h>
4735 int
4736 main ()
4737 {
4738
4739     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4740     choke me
4741     #endif
4742
4743   ;
4744   return 0;
4745 }
4746 _ACEOF
4747 rm -f conftest.$ac_objext
4748 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4749   (eval $ac_compile) 2>conftest.er1
4750   ac_status=$?
4751   grep -v '^ *+' conftest.er1 >conftest.err
4752   rm -f conftest.er1
4753   cat conftest.err >&5
4754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4755   (exit $ac_status); } &&
4756          { ac_try='test -z "$ac_c_werror_flag"
4757                          || test ! -s conftest.err'
4758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4759   (eval $ac_try) 2>&5
4760   ac_status=$?
4761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4762   (exit $ac_status); }; } &&
4763          { ac_try='test -s conftest.$ac_objext'
4764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4765   (eval $ac_try) 2>&5
4766   ac_status=$?
4767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4768   (exit $ac_status); }; }; then
4769   cat >conftest.$ac_ext <<_ACEOF
4770 /* confdefs.h.  */
4771 _ACEOF
4772 cat confdefs.h >>conftest.$ac_ext
4773 cat >>conftest.$ac_ext <<_ACEOF
4774 /* end confdefs.h.  */
4775 #include <gmp.h>
4776     #include <mpfr.h>
4777 int
4778 main ()
4779 {
4780
4781     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4782     choke me
4783     #endif
4784
4785   ;
4786   return 0;
4787 }
4788 _ACEOF
4789 rm -f conftest.$ac_objext
4790 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4791   (eval $ac_compile) 2>conftest.er1
4792   ac_status=$?
4793   grep -v '^ *+' conftest.er1 >conftest.err
4794   rm -f conftest.er1
4795   cat conftest.err >&5
4796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4797   (exit $ac_status); } &&
4798          { ac_try='test -z "$ac_c_werror_flag"
4799                          || test ! -s conftest.err'
4800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4801   (eval $ac_try) 2>&5
4802   ac_status=$?
4803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4804   (exit $ac_status); }; } &&
4805          { ac_try='test -s conftest.$ac_objext'
4806   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4807   (eval $ac_try) 2>&5
4808   ac_status=$?
4809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4810   (exit $ac_status); }; }; then
4811   echo "$as_me:$LINENO: result: yes" >&5
4812 echo "${ECHO_T}yes" >&6
4813 else
4814   echo "$as_me: failed program was:" >&5
4815 sed 's/^/| /' conftest.$ac_ext >&5
4816
4817 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4818 echo "${ECHO_T}buggy but acceptable" >&6
4819 fi
4820 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4821 else
4822   echo "$as_me: failed program was:" >&5
4823 sed 's/^/| /' conftest.$ac_ext >&5
4824
4825 echo "$as_me:$LINENO: result: no" >&5
4826 echo "${ECHO_T}no" >&6; have_gmp=no
4827 fi
4828 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4829   fi
4830
4831   # Check for the MPC header version.
4832   if test x"$have_mpc" != xyes ; then
4833     CFLAGS="$CFLAGS $mpcinc"
4834     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4835 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4836     cat >conftest.$ac_ext <<_ACEOF
4837 /* confdefs.h.  */
4838 _ACEOF
4839 cat confdefs.h >>conftest.$ac_ext
4840 cat >>conftest.$ac_ext <<_ACEOF
4841 /* end confdefs.h.  */
4842 #include <mpc.h>
4843 int
4844 main ()
4845 {
4846
4847     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4848     choke me
4849     #endif
4850
4851   ;
4852   return 0;
4853 }
4854 _ACEOF
4855 rm -f conftest.$ac_objext
4856 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4857   (eval $ac_compile) 2>conftest.er1
4858   ac_status=$?
4859   grep -v '^ *+' conftest.er1 >conftest.err
4860   rm -f conftest.er1
4861   cat conftest.err >&5
4862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4863   (exit $ac_status); } &&
4864          { ac_try='test -z "$ac_c_werror_flag"
4865                          || test ! -s conftest.err'
4866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4867   (eval $ac_try) 2>&5
4868   ac_status=$?
4869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4870   (exit $ac_status); }; } &&
4871          { ac_try='test -s conftest.$ac_objext'
4872   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4873   (eval $ac_try) 2>&5
4874   ac_status=$?
4875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4876   (exit $ac_status); }; }; then
4877   echo "$as_me:$LINENO: result: yes" >&5
4878 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4879 else
4880   echo "$as_me: failed program was:" >&5
4881 sed 's/^/| /' conftest.$ac_ext >&5
4882
4883 echo "$as_me:$LINENO: result: no" >&5
4884 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4885 fi
4886 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4887   fi
4888
4889   # Now check the MPFR library.
4890   if test x"$have_gmp" = xyes; then
4891     saved_LIBS="$LIBS"
4892     LIBS="$LIBS $gmplibs"
4893     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4894 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4895     cat >conftest.$ac_ext <<_ACEOF
4896 /* confdefs.h.  */
4897 _ACEOF
4898 cat confdefs.h >>conftest.$ac_ext
4899 cat >>conftest.$ac_ext <<_ACEOF
4900 /* end confdefs.h.  */
4901 #include <gmp.h>
4902     #include <mpfr.h>
4903 int
4904 main ()
4905 {
4906
4907     mpfr_t n;
4908     mpfr_t x;
4909     int t;
4910     mpfr_init (n);
4911     mpfr_init (x);
4912     mpfr_atan2 (n, n, x, GMP_RNDN);
4913     mpfr_erfc (n, x, GMP_RNDN);
4914     mpfr_subnormalize (x, t, GMP_RNDN);
4915
4916   ;
4917   return 0;
4918 }
4919 _ACEOF
4920 rm -f conftest.$ac_objext conftest$ac_exeext
4921 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4922   (eval $ac_link) 2>conftest.er1
4923   ac_status=$?
4924   grep -v '^ *+' conftest.er1 >conftest.err
4925   rm -f conftest.er1
4926   cat conftest.err >&5
4927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4928   (exit $ac_status); } &&
4929          { ac_try='test -z "$ac_c_werror_flag"
4930                          || test ! -s conftest.err'
4931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4932   (eval $ac_try) 2>&5
4933   ac_status=$?
4934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4935   (exit $ac_status); }; } &&
4936          { ac_try='test -s conftest$ac_exeext'
4937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4938   (eval $ac_try) 2>&5
4939   ac_status=$?
4940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4941   (exit $ac_status); }; }; then
4942   echo "$as_me:$LINENO: result: yes" >&5
4943 echo "${ECHO_T}yes" >&6
4944 else
4945   echo "$as_me: failed program was:" >&5
4946 sed 's/^/| /' conftest.$ac_ext >&5
4947
4948 echo "$as_me:$LINENO: result: no" >&5
4949 echo "${ECHO_T}no" >&6; have_gmp=no
4950 fi
4951 rm -f conftest.err conftest.$ac_objext \
4952       conftest$ac_exeext conftest.$ac_ext
4953     LIBS="$saved_LIBS"
4954   fi
4955
4956   if test x"$have_mpc" = xmaybe; then
4957     saved_LIBS="$LIBS"
4958     LIBS="$LIBS $mpclibs $gmplibs"
4959     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4960 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4961     cat >conftest.$ac_ext <<_ACEOF
4962 /* confdefs.h.  */
4963 _ACEOF
4964 cat confdefs.h >>conftest.$ac_ext
4965 cat >>conftest.$ac_ext <<_ACEOF
4966 /* end confdefs.h.  */
4967 #include <mpc.h>
4968 int
4969 main ()
4970 {
4971
4972     mpc_t n;
4973     mpc_init2 (n, 53);
4974     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
4975     mpc_sin (n, n, MPC_RNDNN);
4976     mpc_cos (n, n, MPC_RNDNN);
4977     mpc_tan (n, n, MPC_RNDNN);
4978     mpc_sinh (n, n, MPC_RNDNN);
4979     mpc_cosh (n, n, MPC_RNDNN);
4980     mpc_tanh (n, n, MPC_RNDNN);
4981     mpc_exp (n, n, MPC_RNDNN);
4982     mpc_log (n, n, MPC_RNDNN);
4983     mpc_sqrt (n, n, MPC_RNDNN);
4984     mpc_proj (n, n, MPC_RNDNN);
4985     mpc_neg (n, n, MPC_RNDNN);
4986     mpc_sqr (n, n, MPC_RNDNN);
4987     mpc_clear (n);
4988
4989   ;
4990   return 0;
4991 }
4992 _ACEOF
4993 rm -f conftest.$ac_objext conftest$ac_exeext
4994 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4995   (eval $ac_link) 2>conftest.er1
4996   ac_status=$?
4997   grep -v '^ *+' conftest.er1 >conftest.err
4998   rm -f conftest.er1
4999   cat conftest.err >&5
5000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5001   (exit $ac_status); } &&
5002          { ac_try='test -z "$ac_c_werror_flag"
5003                          || test ! -s conftest.err'
5004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5005   (eval $ac_try) 2>&5
5006   ac_status=$?
5007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5008   (exit $ac_status); }; } &&
5009          { ac_try='test -s conftest$ac_exeext'
5010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5011   (eval $ac_try) 2>&5
5012   ac_status=$?
5013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5014   (exit $ac_status); }; }; then
5015   echo "$as_me:$LINENO: result: yes" >&5
5016 echo "${ECHO_T}yes" >&6; have_mpc=yes
5017 else
5018   echo "$as_me: failed program was:" >&5
5019 sed 's/^/| /' conftest.$ac_ext >&5
5020
5021 echo "$as_me:$LINENO: result: no" >&5
5022 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5023 fi
5024 rm -f conftest.err conftest.$ac_objext \
5025       conftest$ac_exeext conftest.$ac_ext
5026     LIBS="$saved_LIBS"
5027   fi
5028
5029   CFLAGS="$saved_CFLAGS"
5030
5031   if test x$have_gmp != xyes; then
5032     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5033 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5034 Copies of these libraries' source code can be found at their respective
5035 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5036 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5037 If you obtained GMP and/or MPFR from a vendor distribution package, make
5038 sure that you have installed both the libraries and the header files.
5039 They may be located in separate packages." >&5
5040 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5041 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5042 Copies of these libraries' source code can be found at their respective
5043 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5044 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5045 If you obtained GMP and/or MPFR from a vendor distribution package, make
5046 sure that you have installed both the libraries and the header files.
5047 They may be located in separate packages." >&2;}
5048    { (exit 1); exit 1; }; }
5049   fi
5050 fi
5051
5052 if test x$have_mpc != xyes ; then
5053   mpcinc=
5054   mpclibs=
5055 fi
5056
5057 gmpinc="$mpcinc $gmpinc"
5058 gmplibs="$mpclibs $gmplibs"
5059
5060 # Flags needed for both GMP, MPFR and/or MPC.
5061
5062
5063
5064
5065
5066
5067 # Allow host libstdc++ to be specified for static linking with PPL.
5068
5069 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5070 if test "${with_host_libstdcxx+set}" = set; then
5071   withval="$with_host_libstdcxx"
5072
5073 fi;
5074
5075 case $with_host_libstdcxx in
5076   no|yes)
5077     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5078 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5079    { (exit 1); exit 1; }; }
5080     ;;
5081 esac
5082
5083 # Check for PPL
5084 ppl_major_version=0
5085 ppl_minor_version=10
5086 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
5087 pplinc=
5088
5089
5090 # Check whether --with-ppl or --without-ppl was given.
5091 if test "${with_ppl+set}" = set; then
5092   withval="$with_ppl"
5093
5094 else
5095   with_ppl=no
5096 fi;
5097
5098 # Check whether --with-ppl_include or --without-ppl_include was given.
5099 if test "${with_ppl_include+set}" = set; then
5100   withval="$with_ppl_include"
5101
5102 fi;
5103
5104 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5105 if test "${with_ppl_lib+set}" = set; then
5106   withval="$with_ppl_lib"
5107
5108 fi;
5109
5110 case $with_ppl in
5111   no)
5112     ppllibs=
5113     ;;
5114   *)
5115     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
5116     pplinc="-I$with_ppl/include $pplinc"
5117     LIBS="$ppllibs $LIBS"
5118     ;;
5119 esac
5120 if test "x$with_ppl_include" != x; then
5121   pplinc="-I$with_ppl_include $pplinc"
5122 fi
5123 if test "x$with_ppl_lib" != x; then
5124   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
5125   LIBS="$ppllibs $LIBS"
5126 fi
5127 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5128   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
5129   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5130   LIBS="$ppllibs $LIBS"
5131 fi
5132
5133 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5134 if test "${enable_ppl_version_check+set}" = set; then
5135   enableval="$enable_ppl_version_check"
5136   ENABLE_PPL_CHECK=$enableval
5137 else
5138   ENABLE_PPL_CHECK=yes
5139 fi;
5140
5141 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5142   saved_CFLAGS="$CFLAGS"
5143   CFLAGS="$CFLAGS $pplinc $gmpinc"
5144   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5145 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5146   cat >conftest.$ac_ext <<_ACEOF
5147 /* confdefs.h.  */
5148 _ACEOF
5149 cat confdefs.h >>conftest.$ac_ext
5150 cat >>conftest.$ac_ext <<_ACEOF
5151 /* end confdefs.h.  */
5152 #include "ppl_c.h"
5153 int
5154 main ()
5155 {
5156
5157   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5158   choke me
5159   #endif
5160
5161   ;
5162   return 0;
5163 }
5164 _ACEOF
5165 rm -f conftest.$ac_objext
5166 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5167   (eval $ac_compile) 2>conftest.er1
5168   ac_status=$?
5169   grep -v '^ *+' conftest.er1 >conftest.err
5170   rm -f conftest.er1
5171   cat conftest.err >&5
5172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5173   (exit $ac_status); } &&
5174          { ac_try='test -z "$ac_c_werror_flag"
5175                          || test ! -s conftest.err'
5176   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5177   (eval $ac_try) 2>&5
5178   ac_status=$?
5179   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5180   (exit $ac_status); }; } &&
5181          { ac_try='test -s conftest.$ac_objext'
5182   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5183   (eval $ac_try) 2>&5
5184   ac_status=$?
5185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5186   (exit $ac_status); }; }; then
5187   echo "$as_me:$LINENO: result: yes" >&5
5188 echo "${ECHO_T}yes" >&6
5189 else
5190   echo "$as_me: failed program was:" >&5
5191 sed 's/^/| /' conftest.$ac_ext >&5
5192
5193 echo "$as_me:$LINENO: result: no" >&5
5194 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5195 fi
5196 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5197   CFLAGS="$saved_CFLAGS"
5198 fi
5199
5200 # Flags needed for PPL
5201
5202
5203
5204
5205 # Check for CLOOG
5206 clooglibs=" -lcloog "
5207 clooginc=" -DCLOOG_PPL_BACKEND "
5208
5209
5210 # Check whether --with-cloog or --without-cloog was given.
5211 if test "${with_cloog+set}" = set; then
5212   withval="$with_cloog"
5213
5214 else
5215   with_cloog=no
5216 fi;
5217
5218 # Check whether --with-cloog_include or --without-cloog_include was given.
5219 if test "${with_cloog_include+set}" = set; then
5220   withval="$with_cloog_include"
5221
5222 fi;
5223
5224 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5225 if test "${with_cloog_lib+set}" = set; then
5226   withval="$with_cloog_lib"
5227
5228 fi;
5229
5230 case $with_cloog in
5231   no)
5232     clooglibs=
5233     clooginc=
5234     ;;
5235   *)
5236     clooglibs="-L$with_cloog/lib -lcloog"
5237     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5238     LIBS="$clooglibs $LIBS"
5239     ;;
5240 esac
5241 if test "x$with_cloog_include" != x; then
5242   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5243 fi
5244 if test "x$with_cloog_lib" != x; then
5245   clooglibs="-L$with_cloog_lib -lcloog"
5246   LIBS="$clooglibs $LIBS"
5247 fi
5248 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5249   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5250   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5251   LIBS="$clooglibs $LIBS"
5252 fi
5253
5254 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5255 if test "${enable_cloog_version_check+set}" = set; then
5256   enableval="$enable_cloog_version_check"
5257   ENABLE_CLOOG_CHECK=$enableval
5258 else
5259   ENABLE_CLOOG_CHECK=yes
5260 fi;
5261
5262 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5263   saved_CFLAGS="$CFLAGS"
5264   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5265   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5266 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5267   cat >conftest.$ac_ext <<_ACEOF
5268 /* confdefs.h.  */
5269 _ACEOF
5270 cat confdefs.h >>conftest.$ac_ext
5271 cat >>conftest.$ac_ext <<_ACEOF
5272 /* end confdefs.h.  */
5273 #include "cloog/cloog.h"
5274 int
5275 main ()
5276 {
5277
5278   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5279   choke me
5280   #endif
5281
5282   ;
5283   return 0;
5284 }
5285 _ACEOF
5286 rm -f conftest.$ac_objext
5287 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5288   (eval $ac_compile) 2>conftest.er1
5289   ac_status=$?
5290   grep -v '^ *+' conftest.er1 >conftest.err
5291   rm -f conftest.er1
5292   cat conftest.err >&5
5293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5294   (exit $ac_status); } &&
5295          { ac_try='test -z "$ac_c_werror_flag"
5296                          || test ! -s conftest.err'
5297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5298   (eval $ac_try) 2>&5
5299   ac_status=$?
5300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5301   (exit $ac_status); }; } &&
5302          { ac_try='test -s conftest.$ac_objext'
5303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5304   (eval $ac_try) 2>&5
5305   ac_status=$?
5306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5307   (exit $ac_status); }; }; then
5308   echo "$as_me:$LINENO: result: yes" >&5
5309 echo "${ECHO_T}yes" >&6
5310 else
5311   echo "$as_me: failed program was:" >&5
5312 sed 's/^/| /' conftest.$ac_ext >&5
5313
5314 echo "$as_me:$LINENO: result: no" >&5
5315 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5316 fi
5317 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5318   CFLAGS="$saved_CFLAGS"
5319 fi
5320
5321 # Flags needed for CLOOG
5322
5323
5324
5325
5326 # By default, C is the only stage 1 language.
5327 stage1_languages=,c,
5328
5329 # Figure out what language subdirectories are present.
5330 # Look if the user specified --enable-languages="..."; if not, use
5331 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5332 # go away some day.
5333 # NB:  embedded tabs in this IF block -- do not untabify
5334 if test -d ${srcdir}/gcc; then
5335   if test x"${enable_languages+set}" != xset; then
5336     if test x"${LANGUAGES+set}" = xset; then
5337       enable_languages="${LANGUAGES}"
5338         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5339     else
5340       enable_languages=all
5341     fi
5342   else
5343     if test x"${enable_languages}" = x ||
5344        test x"${enable_languages}" = xyes;
5345        then
5346       echo configure.in: --enable-languages needs at least one language argument 1>&2
5347       exit 1
5348     fi
5349   fi
5350   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5351
5352   # 'f95' is the old name for the 'fortran' language. We issue a warning
5353   # and make the substitution.
5354   case ,${enable_languages}, in
5355     *,f95,*)
5356       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5357       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5358       ;;
5359   esac
5360
5361   # First scan to see if an enabled language requires some other language.
5362   # We assume that a given config-lang.in will list all the language
5363   # front ends it requires, even if some are required indirectly.
5364   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5365     case ${lang_frag} in
5366       ..) ;;
5367       # The odd quoting in the next line works around
5368       # an apparent bug in bash 1.12 on linux.
5369       ${srcdir}/gcc/[*]/config-lang.in) ;;
5370       *)
5371         # From the config-lang.in, get $language, $lang_requires
5372         language=
5373         lang_requires=
5374         . ${lang_frag}
5375         for other in ${lang_requires} ; do
5376           case ,${enable_languages}, in
5377             *,$other,*) ;;
5378             *,all,*) ;;
5379             *,$language,*)
5380               echo " \`$other' language required by \`$language'; enabling" 1>&2
5381               enable_languages="${enable_languages},${other}"
5382               ;;
5383           esac
5384         done
5385         ;;
5386     esac
5387   done
5388
5389   new_enable_languages=,c,
5390   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5391   potential_languages=,c,
5392
5393   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5394     case ${lang_frag} in
5395       ..) ;;
5396       # The odd quoting in the next line works around
5397       # an apparent bug in bash 1.12 on linux.
5398       ${srcdir}/gcc/[*]/config-lang.in) ;;
5399       *)
5400         # From the config-lang.in, get $language, $target_libs,
5401         # $lang_dirs, $boot_language, and $build_by_default
5402         language=
5403         target_libs=
5404         lang_dirs=
5405         subdir_requires=
5406         boot_language=no
5407         build_by_default=yes
5408         . ${lang_frag}
5409         if test x${language} = x; then
5410           echo "${lang_frag} doesn't set \$language." 1>&2
5411           exit 1
5412         fi
5413
5414         case ,${enable_languages}, in
5415           *,${language},*)
5416             # Language was explicitly selected; include it.
5417             add_this_lang=yes
5418             ;;
5419           *,all,*)
5420             # 'all' was selected, select it if it is a default language
5421             add_this_lang=${build_by_default}
5422             ;;
5423           *)
5424             add_this_lang=no
5425             ;;
5426         esac
5427
5428         # Disable languages that need other directories if these aren't available.
5429         for i in $subdir_requires; do
5430           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5431           case ,${enable_languages}, in
5432             *,${language},*)
5433               # Specifically requested language; tell them.
5434               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5435 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5436    { (exit 1); exit 1; }; }
5437               ;;
5438             *)
5439               # Silently disable.
5440               add_this_lang=unsupported
5441               ;;
5442           esac
5443         done
5444
5445         # Disable Ada if no preexisting GNAT is available.
5446         case ,${enable_languages},:${language}:${have_gnat} in
5447           *,${language},*:ada:no)
5448             # Specifically requested language; tell them.
5449             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5450 echo "$as_me: error: GNAT is required to build $language" >&2;}
5451    { (exit 1); exit 1; }; }
5452             ;;
5453           *:ada:no)
5454             # Silently disable.
5455             add_this_lang=unsupported
5456             ;;
5457         esac
5458
5459         # Disable a language that is unsupported by the target.
5460         case " $unsupported_languages " in
5461           *" $language "*)
5462             add_this_lang=unsupported
5463             ;;
5464         esac
5465
5466         case $add_this_lang in
5467           unsupported)
5468             # Remove language-dependent dirs.
5469             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5470             ;;
5471           no)
5472             # Remove language-dependent dirs; still show language as supported.
5473             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5474             potential_languages="${potential_languages}${language},"
5475             ;;
5476           yes)
5477             new_enable_languages="${new_enable_languages}${language},"
5478             potential_languages="${potential_languages}${language},"
5479             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5480             case ${boot_language} in
5481               yes)
5482                 # Add to (comma-separated) list of stage 1 languages.
5483                 stage1_languages="${stage1_languages}${language},"
5484                 ;;
5485             esac
5486             ;;
5487         esac
5488         ;;
5489     esac
5490   done
5491
5492   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5493 if test "${enable_stage1_languages+set}" = set; then
5494   enableval="$enable_stage1_languages"
5495   case ,${enable_stage1_languages}, in
5496     ,no,|,,)
5497       # Set it to something that will have no effect in the loop below
5498       enable_stage1_languages=c ;;
5499     ,yes,)
5500       enable_stage1_languages=`echo $new_enable_languages | \
5501         sed -e "s/^,//" -e "s/,$//" ` ;;
5502     *,all,*)
5503       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5504         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5505   esac
5506
5507   # Add "good" languages from enable_stage1_languages to stage1_languages,
5508   # while "bad" languages go in missing_languages.  Leave no duplicates.
5509   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5510     case $potential_languages in
5511       *,$i,*)
5512         case $stage1_languages in
5513           *,$i,*) ;;
5514           *) stage1_languages="$stage1_languages$i," ;;
5515         esac ;;
5516       *)
5517         case $missing_languages in
5518           *,$i,*) ;;
5519           *) missing_languages="$missing_languages$i," ;;
5520         esac ;;
5521      esac
5522   done
5523 fi;
5524
5525   # Remove leading/trailing commas that were added for simplicity
5526   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5527   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5528   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5529   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5530
5531   if test "x$missing_languages" != x; then
5532     { { echo "$as_me:$LINENO: error:
5533 The following requested languages could not be built: ${missing_languages}
5534 Supported languages are: ${potential_languages}" >&5
5535 echo "$as_me: error:
5536 The following requested languages could not be built: ${missing_languages}
5537 Supported languages are: ${potential_languages}" >&2;}
5538    { (exit 1); exit 1; }; }
5539   fi
5540   if test "x$new_enable_languages" != "x$enable_languages"; then
5541     echo The following languages will be built: ${new_enable_languages}
5542     enable_languages="$new_enable_languages"
5543   fi
5544
5545
5546   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5547 fi
5548
5549 # Handle --disable-<component> generically.
5550 for dir in $configdirs $build_configdirs $target_configdirs ; do
5551   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5552   varname=`echo $dirname | sed -e s/+/_/g`
5553   if eval test x\${enable_${varname}} "=" xno ; then
5554     noconfigdirs="$noconfigdirs $dir"
5555   fi
5556 done
5557
5558 # Check for Boehm's garbage collector
5559 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5560 if test "${enable_objc_gc+set}" = set; then
5561   enableval="$enable_objc_gc"
5562   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5563   *,objc,*:*:yes:*target-boehm-gc*)
5564     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5565 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5566    { (exit 1); exit 1; }; }
5567     ;;
5568 esac
5569 fi;
5570
5571 # Make sure we only build Boehm's garbage collector if required.
5572 case ,${enable_languages},:${enable_objc_gc} in
5573   *,objc,*:yes)
5574     # Keep target-boehm-gc if requested for Objective-C.
5575     ;;
5576   *)
5577     # Otherwise remove target-boehm-gc depending on target-libjava.
5578     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5579       noconfigdirs="$noconfigdirs target-boehm-gc"
5580     fi
5581     ;;
5582 esac
5583
5584 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5585 # $build_configdirs and $target_configdirs.
5586 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5587
5588 notsupp=""
5589 for dir in . $skipdirs $noconfigdirs ; do
5590   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5591   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5592     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5593     if test -r $srcdir/$dirname/configure ; then
5594       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5595         true
5596       else
5597         notsupp="$notsupp $dir"
5598       fi
5599     fi
5600   fi
5601   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5602     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5603     if test -r $srcdir/$dirname/configure ; then
5604       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5605         true
5606       else
5607         notsupp="$notsupp $dir"
5608       fi
5609     fi
5610   fi
5611   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5612     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5613     if test -r $srcdir/$dirname/configure ; then
5614       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5615         true
5616       else
5617         notsupp="$notsupp $dir"
5618       fi
5619     fi
5620   fi
5621 done
5622
5623 # Sometimes the tools are distributed with libiberty but with no other
5624 # libraries.  In that case, we don't want to build target-libiberty.
5625 # Don't let libgcc imply libiberty either.
5626 if test -n "${target_configdirs}" ; then
5627   libgcc=
5628   others=
5629   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5630     if test "$i" = "libgcc"; then
5631       libgcc=target-libgcc
5632     elif test "$i" != "libiberty" ; then
5633       if test -r $srcdir/$i/configure ; then
5634         others=yes;
5635         break;
5636       fi
5637     fi
5638   done
5639   if test -z "${others}" ; then
5640     target_configdirs=$libgcc
5641   fi
5642 fi
5643
5644 # Quietly strip out all directories which aren't configurable in this tree.
5645 # This relies on all configurable subdirectories being autoconfiscated, which
5646 # is now the case.
5647 build_configdirs_all="$build_configdirs"
5648 build_configdirs=
5649 for i in ${build_configdirs_all} ; do
5650   j=`echo $i | sed -e s/build-//g`
5651   if test -f ${srcdir}/$j/configure ; then
5652     build_configdirs="${build_configdirs} $i"
5653   fi
5654 done
5655
5656 configdirs_all="$configdirs"
5657 configdirs=
5658 for i in ${configdirs_all} ; do
5659   if test -f ${srcdir}/$i/configure ; then
5660     configdirs="${configdirs} $i"
5661   fi
5662 done
5663
5664 target_configdirs_all="$target_configdirs"
5665 target_configdirs=
5666 for i in ${target_configdirs_all} ; do
5667   j=`echo $i | sed -e s/target-//g`
5668   if test -f ${srcdir}/$j/configure ; then
5669     target_configdirs="${target_configdirs} $i"
5670   fi
5671 done
5672
5673 # Produce a warning message for the subdirs we can't configure.
5674 # This isn't especially interesting in the Cygnus tree, but in the individual
5675 # FSF releases, it's important to let people know when their machine isn't
5676 # supported by the one or two programs in a package.
5677
5678 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5679   # If $appdirs is non-empty, at least one of those directories must still
5680   # be configured, or we error out.  (E.g., if the gas release supports a
5681   # specified target in some subdirs but not the gas subdir, we shouldn't
5682   # pretend that all is well.)
5683   if test -n "$appdirs" ; then
5684     for dir in $appdirs ; do
5685       if test -r $dir/Makefile.in ; then
5686         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5687           appdirs=""
5688           break
5689         fi
5690         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5691           appdirs=""
5692           break
5693         fi
5694       fi
5695     done
5696     if test -n "$appdirs" ; then
5697       echo "*** This configuration is not supported by this package." 1>&2
5698       exit 1
5699     fi
5700   fi
5701   # Okay, some application will build, or we don't care to check.  Still
5702   # notify of subdirs not getting built.
5703   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5704   echo "    ${notsupp}" 1>&2
5705   echo "    (Any other directories should still work fine.)" 1>&2
5706 fi
5707
5708 case "$host" in
5709   *msdosdjgpp*)
5710     enable_gdbtk=no ;;
5711 esac
5712
5713 # To find our prefix, in gcc_cv_tool_prefix.
5714
5715 # The user is always right.
5716 if test "${PATH_SEPARATOR+set}" != set; then
5717   echo "#! /bin/sh" >conf$$.sh
5718   echo  "exit 0"   >>conf$$.sh
5719   chmod +x conf$$.sh
5720   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5721     PATH_SEPARATOR=';'
5722   else
5723     PATH_SEPARATOR=:
5724   fi
5725   rm -f conf$$.sh
5726 fi
5727
5728
5729
5730 if test "x$exec_prefix" = xNONE; then
5731         if test "x$prefix" = xNONE; then
5732                 gcc_cv_tool_prefix=$ac_default_prefix
5733         else
5734                 gcc_cv_tool_prefix=$prefix
5735         fi
5736 else
5737         gcc_cv_tool_prefix=$exec_prefix
5738 fi
5739
5740 # If there is no compiler in the tree, use the PATH only.  In any
5741 # case, if there is no compiler in the tree nobody should use
5742 # AS_FOR_TARGET and LD_FOR_TARGET.
5743 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5744     gcc_version=`cat $srcdir/gcc/BASE-VER`
5745     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5746     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5747     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5748     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5749     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5750     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5751 else
5752     gcc_cv_tool_dirs=
5753 fi
5754
5755 if test x$build = x$target && test -n "$md_exec_prefix"; then
5756         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5757 fi
5758
5759
5760
5761 copy_dirs=
5762
5763
5764 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5765 if test "${with_build_sysroot+set}" = set; then
5766   withval="$with_build_sysroot"
5767   if test x"$withval" != x ; then
5768      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5769    fi
5770 else
5771   SYSROOT_CFLAGS_FOR_TARGET=
5772 fi;
5773
5774
5775
5776 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5777 if test "${with_debug_prefix_map+set}" = set; then
5778   withval="$with_debug_prefix_map"
5779   if test x"$withval" != x; then
5780      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5781      for debug_map in $withval; do
5782        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5783      done
5784    fi
5785 else
5786   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5787 fi;
5788
5789
5790 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5791 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5792 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5793 # We want to ensure that TARGET libraries (which we know are built with
5794 # gcc) are built with "-O2 -g", so include those options when setting
5795 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5796 if test "x$CFLAGS_FOR_TARGET" = x; then
5797   CFLAGS_FOR_TARGET=$CFLAGS
5798   case " $CFLAGS " in
5799     *" -O2 "*) ;;
5800     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5801   esac
5802   case " $CFLAGS " in
5803     *" -g "* | *" -g3 "*) ;;
5804     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5805   esac
5806 fi
5807
5808
5809 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5810   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5811   case " $CXXFLAGS " in
5812     *" -O2 "*) ;;
5813     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5814   esac
5815   case " $CXXFLAGS " in
5816     *" -g "* | *" -g3 "*) ;;
5817     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5818   esac
5819 fi
5820
5821
5822 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5823 # the named directory are copied to $(tooldir)/sys-include.
5824 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5825   if test x${is_cross_compiler} = xno ; then
5826     echo 1>&2 '***' --with-headers is only supported when cross compiling
5827     exit 1
5828   fi
5829   if test x"${with_headers}" != xyes ; then
5830     x=${gcc_cv_tool_prefix}
5831     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5832   fi
5833 fi
5834
5835 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5836 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5837 # are permitted.
5838 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5839   if test x${is_cross_compiler} = xno ; then
5840     echo 1>&2 '***' --with-libs is only supported when cross compiling
5841     exit 1
5842   fi
5843   if test x"${with_libs}" != xyes ; then
5844     # Copy the libraries in reverse order, so that files in the first named
5845     # library override files in subsequent libraries.
5846     x=${gcc_cv_tool_prefix}
5847     for l in ${with_libs}; do
5848       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5849     done
5850   fi
5851 fi
5852
5853 # Set with_gnu_as and with_gnu_ld as appropriate.
5854 #
5855 # This is done by determining whether or not the appropriate directory
5856 # is available, and by checking whether or not specific configurations
5857 # have requested that this magic not happen.
5858 #
5859 # The command line options always override the explicit settings in
5860 # configure.in, and the settings in configure.in override this magic.
5861 #
5862 # If the default for a toolchain is to use GNU as and ld, and you don't
5863 # want to do that, then you should use the --without-gnu-as and
5864 # --without-gnu-ld options for the configure script.
5865
5866 if test x${use_gnu_as} = x &&
5867    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5868   with_gnu_as=yes
5869   extra_host_args="$extra_host_args --with-gnu-as"
5870 fi
5871
5872 if test x${use_gnu_ld} = x &&
5873    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5874   with_gnu_ld=yes
5875   extra_host_args="$extra_host_args --with-gnu-ld"
5876 fi
5877
5878 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5879 # can detect this case.
5880
5881 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5882   with_newlib=yes
5883   extra_host_args="$extra_host_args --with-newlib"
5884 fi
5885
5886 # Handle ${copy_dirs}
5887 set fnord ${copy_dirs}
5888 shift
5889 while test $# != 0 ; do
5890   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5891     :
5892   else
5893     echo Copying $1 to $2
5894
5895     # Use the install script to create the directory and all required
5896     # parent directories.
5897     if test -d $2 ; then
5898       :
5899     else
5900       echo >config.temp
5901       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5902     fi
5903
5904     # Copy the directory, assuming we have tar.
5905     # FIXME: Should we use B in the second tar?  Not all systems support it.
5906     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5907
5908     # It is the responsibility of the user to correctly adjust all
5909     # symlinks.  If somebody can figure out how to handle them correctly
5910     # here, feel free to add the code.
5911
5912     echo $1 > $2/COPIED
5913   fi
5914   shift; shift
5915 done
5916
5917 # Determine a target-dependent exec_prefix that the installed
5918 # gcc will search in.  Keep this list sorted by triplet, with
5919 # the *-*-osname triplets last.
5920 md_exec_prefix=
5921 case "${target}" in
5922   alpha*-*-*vms*)
5923     md_exec_prefix=/gnu/lib/gcc-lib
5924     ;;
5925   i[34567]86-pc-msdosdjgpp*)
5926     md_exec_prefix=/dev/env/DJDIR/bin
5927     ;;
5928   i[34567]86-*-sco3.2v5*)
5929     if test $with_gnu_as = yes; then
5930       md_exec_prefix=/usr/gnu/bin
5931     else
5932       md_exec_prefix=/usr/ccs/bin/elf
5933     fi
5934     ;;
5935
5936   mn10300-*-* | \
5937   powerpc-*-chorusos* | \
5938   powerpc*-*-eabi* | \
5939   powerpc*-*-sysv* | \
5940   powerpc*-*-kaos* | \
5941   s390x-ibm-tpf*)
5942     md_exec_prefix=/usr/ccs/bin
5943     ;;
5944   sparc64-*-elf*)
5945     ;;
5946   v850*-*-*)
5947     md_exec_prefix=/usr/ccs/bin
5948     ;;
5949   xtensa*-*-elf*)
5950     ;;
5951
5952   *-*-beos* | \
5953   *-*-elf* | \
5954   *-*-hpux* | \
5955   *-*-netware* | \
5956   *-*-nto-qnx* | \
5957   *-*-rtems* | \
5958   *-*-solaris2* | \
5959   *-*-sysv[45]* | \
5960   *-*-vxworks* | \
5961   *-wrs-windiss)
5962     md_exec_prefix=/usr/ccs/bin
5963     ;;
5964 esac
5965
5966 extra_arflags_for_target=
5967 extra_nmflags_for_target=
5968 extra_ranlibflags_for_target=
5969 target_makefile_frag=/dev/null
5970 case "${target}" in
5971   mep*-*-*)
5972     target_makefile_frag="config/mt-mep"
5973     ;;
5974   spu-*-*)
5975     target_makefile_frag="config/mt-spu"
5976     ;;
5977   mips*-sde-elf*)
5978     target_makefile_frag="config/mt-sde"
5979     ;;
5980   mipsisa*-*-elfoabi*)
5981     target_makefile_frag="config/mt-mips-elfoabi"
5982     ;;
5983   mips*-*-*linux* | mips*-*-gnu*)
5984     target_makefile_frag="config/mt-mips-gnu"
5985     ;;
5986   *-*-netware*)
5987     target_makefile_frag="config/mt-netware"
5988     ;;
5989   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5990     target_makefile_frag="config/mt-gnu"
5991     ;;
5992   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5993     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5994     # commands to handle both 32-bit and 64-bit objects.  These flags are
5995     # harmless if we're using GNU nm or ar.
5996     extra_arflags_for_target=" -X32_64"
5997     extra_nmflags_for_target=" -B -X32_64"
5998     ;;
5999   *-*-darwin*)
6000     # ranlib from Darwin requires the -c flag to look at common symbols.
6001     extra_ranlibflags_for_target=" -c"
6002     ;;
6003   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6004     target_makefile_frag="config/mt-wince"
6005     ;;
6006 esac
6007
6008 alphaieee_frag=/dev/null
6009 case $target in
6010   alpha*-*-*)
6011     # This just makes sure to use the -mieee option to build target libs.
6012     # This should probably be set individually by each library.
6013     alphaieee_frag="config/mt-alphaieee"
6014     ;;
6015 esac
6016
6017 # If --enable-target-optspace always use -Os instead of -O2 to build
6018 # the target libraries, similarly if it is not specified, use -Os
6019 # on selected platforms.
6020 ospace_frag=/dev/null
6021 case "${enable_target_optspace}:${target}" in
6022   yes:*)
6023     ospace_frag="config/mt-ospace"
6024     ;;
6025   :d30v-*)
6026     ospace_frag="config/mt-d30v"
6027     ;;
6028   :m32r-* | :d10v-* | :fr30-*)
6029     ospace_frag="config/mt-ospace"
6030     ;;
6031   no:* | :*)
6032     ;;
6033   *)
6034     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6035     ;;
6036 esac
6037
6038 # Default to using --with-stabs for certain targets.
6039 if test x${with_stabs} = x ; then
6040   case "${target}" in
6041   mips*-*-irix[56]*)
6042     ;;
6043   mips*-*-* | alpha*-*-osf*)
6044     with_stabs=yes;
6045     extra_host_args="${extra_host_args} --with-stabs"
6046     ;;
6047   esac
6048 fi
6049
6050 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6051 # them automatically.
6052 case "${host}" in
6053   hppa*64*-*-hpux11*)
6054     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6055     ;;
6056 esac
6057
6058 # Some systems (e.g., one of the i386-aix systems the gas testers are
6059 # using) don't handle "\$" correctly, so don't use it here.
6060 tooldir='${exec_prefix}'/${target_noncanonical}
6061 build_tooldir=${tooldir}
6062
6063 # Create a .gdbinit file which runs the one in srcdir
6064 # and tells GDB to look there for source files.
6065
6066 if test -r ${srcdir}/.gdbinit ; then
6067   case ${srcdir} in
6068     .) ;;
6069     *) cat > ./.gdbinit <<EOF
6070 # ${NO_EDIT}
6071 dir ${srcdir}
6072 dir .
6073 source ${srcdir}/.gdbinit
6074 EOF
6075     ;;
6076   esac
6077 fi
6078
6079 # Make sure that the compiler is able to generate an executable.  If it
6080 # can't, we are probably in trouble.  We don't care whether we can run the
6081 # executable--we might be using a cross compiler--we only care whether it
6082 # can be created.  At this point the main configure script has set CC.
6083 we_are_ok=no
6084 echo "int main () { return 0; }" > conftest.c
6085 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6086 if test $? = 0 ; then
6087   if test -s conftest || test -s conftest.exe ; then
6088     we_are_ok=yes
6089   fi
6090 fi
6091 case $we_are_ok in
6092   no)
6093     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6094     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6095     rm -f conftest*
6096     exit 1
6097     ;;
6098 esac
6099 rm -f conftest*
6100
6101 # The Solaris /usr/ucb/cc compiler does not appear to work.
6102 case "${host}" in
6103   sparc-sun-solaris2*)
6104       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6105       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6106           could_use=
6107           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6108           if test -d /opt/cygnus/bin ; then
6109               if test "$could_use" = "" ; then
6110                   could_use="/opt/cygnus/bin"
6111               else
6112                   could_use="$could_use or /opt/cygnus/bin"
6113               fi
6114           fi
6115         if test "$could_use" = "" ; then
6116             echo "Warning: compilation may fail because you're using"
6117             echo "/usr/ucb/cc.  You should change your PATH or CC "
6118             echo "variable and rerun configure."
6119         else
6120             echo "Warning: compilation may fail because you're using"
6121             echo "/usr/ucb/cc, when you should use the C compiler from"
6122             echo "$could_use.  You should change your"
6123             echo "PATH or CC variable and rerun configure."
6124         fi
6125       fi
6126   ;;
6127 esac
6128
6129 # Decide which environment variable is used to find dynamic libraries.
6130 case "${host}" in
6131   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6132   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6133   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6134   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6135 esac
6136
6137 # On systems where the dynamic library environment variable is PATH,
6138 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6139 # built executables to PATH.
6140 if test "$RPATH_ENVVAR" = PATH; then
6141   GCC_SHLIB_SUBDIR=/shlib
6142 else
6143   GCC_SHLIB_SUBDIR=
6144 fi
6145
6146 # Record target_configdirs and the configure arguments for target and
6147 # build configuration in Makefile.
6148 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6149 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6150
6151 # Determine whether gdb needs tk/tcl or not.
6152 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6153 # and in that case we want gdb to be built without tk.  Ugh!
6154 # In fact I believe gdb is the *only* package directly dependent on tk,
6155 # so we should be able to put the 'maybe's in unconditionally and
6156 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6157 # 100% sure that that's safe though.
6158
6159 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6160 case "$enable_gdbtk" in
6161   no)
6162     GDB_TK="" ;;
6163   yes)
6164     GDB_TK="${gdb_tk}" ;;
6165   *)
6166     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6167     # distro.  Eventually someone will fix this and move Insight, nee
6168     # gdbtk to a separate directory.
6169     if test -d ${srcdir}/gdb/gdbtk ; then
6170       GDB_TK="${gdb_tk}"
6171     else
6172       GDB_TK=""
6173     fi
6174     ;;
6175 esac
6176 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6177 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6178
6179 # Strip out unwanted targets.
6180
6181 # While at that, we remove Makefiles if we were started for recursive
6182 # configuration, so that the top-level Makefile reconfigures them,
6183 # like we used to do when configure itself was recursive.
6184
6185 # Loop over modules.  $extrasub must be used with care, limiting as
6186 # much as possible the usage of range addresses.  That's because autoconf
6187 # splits the sed script to overcome limits in the number of commands,
6188 # and relying on carefully-timed sed passes may turn out to be very hard
6189 # to maintain later.  In this particular case, you just have to be careful
6190 # not to nest @if/@endif pairs, because configure will not warn you at all.
6191
6192 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6193 if test "${enable_bootstrap+set}" = set; then
6194   enableval="$enable_bootstrap"
6195
6196 else
6197   enable_bootstrap=default
6198 fi;
6199
6200 # Issue errors and warnings for invalid/strange bootstrap combinations.
6201 case "$configdirs" in
6202   *gcc*) have_compiler=yes ;;
6203   *) have_compiler=no ;;
6204 esac
6205
6206 case "$have_compiler:$host:$target:$enable_bootstrap" in
6207   *:*:*:no) ;;
6208
6209   # Default behavior.  Enable bootstrap if we have a compiler
6210   # and we are in a native configuration.
6211   yes:$build:$build:default)
6212     enable_bootstrap=yes ;;
6213
6214   *:*:*:default)
6215     enable_bootstrap=no ;;
6216
6217   # We have a compiler and we are in a native configuration, bootstrap is ok
6218   yes:$build:$build:yes)
6219     ;;
6220
6221   # Other configurations, but we have a compiler.  Assume the user knows
6222   # what he's doing.
6223   yes:*:*:yes)
6224     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6225 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6226     ;;
6227
6228   # No compiler: if they passed --enable-bootstrap explicitly, fail
6229   no:*:*:yes)
6230     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6231 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6232    { (exit 1); exit 1; }; } ;;
6233
6234   # Fail if wrong command line
6235   *)
6236     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6237 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6238    { (exit 1); exit 1; }; }
6239     ;;
6240 esac
6241
6242 # Adjust the toplevel makefile according to whether bootstrap was selected.
6243 case "$enable_bootstrap" in
6244   yes)
6245     bootstrap_suffix=bootstrap ;;
6246   no)
6247     bootstrap_suffix=no-bootstrap ;;
6248 esac
6249
6250 for module in ${build_configdirs} ; do
6251   if test -z "${no_recursion}" \
6252      && test -f ${build_subdir}/${module}/Makefile; then
6253     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6254     rm -f ${build_subdir}/${module}/Makefile
6255   fi
6256   extrasub="$extrasub
6257 /^@if build-$module\$/d
6258 /^@endif build-$module\$/d
6259 /^@if build-$module-$bootstrap_suffix\$/d
6260 /^@endif build-$module-$bootstrap_suffix\$/d"
6261 done
6262 for module in ${configdirs} ; do
6263   if test -z "${no_recursion}"; then
6264     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6265       if test -f ${file}; then
6266         echo 1>&2 "*** removing ${file} to force reconfigure"
6267         rm -f ${file}
6268       fi
6269     done
6270   fi
6271   extrasub="$extrasub
6272 /^@if $module\$/d
6273 /^@endif $module\$/d
6274 /^@if $module-$bootstrap_suffix\$/d
6275 /^@endif $module-$bootstrap_suffix\$/d"
6276 done
6277 for module in ${target_configdirs} ; do
6278   if test -z "${no_recursion}" \
6279      && test -f ${target_subdir}/${module}/Makefile; then
6280     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6281     rm -f ${target_subdir}/${module}/Makefile
6282   fi
6283   extrasub="$extrasub
6284 /^@if target-$module\$/d
6285 /^@endif target-$module\$/d
6286 /^@if target-$module-$bootstrap_suffix\$/d
6287 /^@endif target-$module-$bootstrap_suffix\$/d"
6288 done
6289
6290 extrasub="$extrasub
6291 /^@if /,/^@endif /d"
6292
6293 # Create the serialization dependencies.  This uses a temporary file.
6294
6295 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6296 if test "${enable_serial_configure+set}" = set; then
6297   enableval="$enable_serial_configure"
6298
6299 fi;
6300
6301 case ${enable_serial_configure} in
6302   yes)
6303     enable_serial_build_configure=yes
6304     enable_serial_host_configure=yes
6305     enable_serial_target_configure=yes
6306     ;;
6307 esac
6308
6309 # These force 'configure's to be done one at a time, to avoid problems
6310 # with contention over a shared config.cache.
6311 rm -f serdep.tmp
6312 echo '# serdep.tmp' > serdep.tmp
6313 olditem=
6314 test "x${enable_serial_build_configure}" = xyes &&
6315 for item in ${build_configdirs} ; do
6316   case ${olditem} in
6317     "") ;;
6318     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6319   esac
6320   olditem=${item}
6321 done
6322 olditem=
6323 test "x${enable_serial_host_configure}" = xyes &&
6324 for item in ${configdirs} ; do
6325   case ${olditem} in
6326     "") ;;
6327     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6328   esac
6329   olditem=${item}
6330 done
6331 olditem=
6332 test "x${enable_serial_target_configure}" = xyes &&
6333 for item in ${target_configdirs} ; do
6334   case ${olditem} in
6335     "") ;;
6336     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6337   esac
6338   olditem=${item}
6339 done
6340 serialization_dependencies=serdep.tmp
6341
6342
6343 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6344 # target, nonopt, and variable assignments.  These are the ones we
6345 # might not want to pass down to subconfigures.  Also strip
6346 # program-prefix, program-suffix, and program-transform-name, so that
6347 # we can pass down a consistent program-transform-name.
6348 baseargs=
6349 keep_next=no
6350 skip_next=no
6351 eval "set -- $ac_configure_args"
6352 for ac_arg
6353 do
6354   if test X"$skip_next" = X"yes"; then
6355     skip_next=no
6356     continue
6357   fi
6358   if test X"$keep_next" = X"yes"; then
6359     case $ac_arg in
6360       *\'*)
6361         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6362     esac
6363     baseargs="$baseargs '$ac_arg'"
6364     keep_next=no
6365     continue
6366   fi
6367
6368   # Handle separated arguments.  Based on the logic generated by
6369   # autoconf 2.59.
6370   case $ac_arg in
6371     *=* | --config-cache | -C | -disable-* | --disable-* \
6372       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6373       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6374       | -with-* | --with-* | -without-* | --without-* | --x)
6375       separate_arg=no
6376       ;;
6377     -*)
6378       separate_arg=yes
6379       ;;
6380     *)
6381       separate_arg=no
6382       ;;
6383   esac
6384
6385   case "$ac_arg" in
6386     --no*)
6387       continue
6388       ;;
6389     --c* | \
6390     --sr* | \
6391     --ho* | \
6392     --bu* | \
6393     --t* | \
6394     --program-* | \
6395     -cache_file* | \
6396     -srcdir* | \
6397     -host* | \
6398     -build* | \
6399     -target* | \
6400     -program-prefix* | \
6401     -program-suffix* | \
6402     -program-transform-name* )
6403       skip_next=$separate_arg
6404       continue
6405       ;;
6406     -*)
6407       # An option.  Add it.
6408       case $ac_arg in
6409         *\'*)
6410           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6411       esac
6412       baseargs="$baseargs '$ac_arg'"
6413       keep_next=$separate_arg
6414       ;;
6415     *)
6416       # Either a variable assignment, or a nonopt (triplet).  Don't
6417       # pass it down; let the Makefile handle this.
6418       continue
6419       ;;
6420   esac
6421 done
6422 # Remove the initial space we just introduced and, as these will be
6423 # expanded by make, quote '$'.
6424 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6425
6426 # Add in --program-transform-name, after --program-prefix and
6427 # --program-suffix have been applied to it.  Autoconf has already
6428 # doubled dollar signs and backslashes in program_transform_name; we want
6429 # the backslashes un-doubled, and then the entire thing wrapped in single
6430 # quotes, because this will be expanded first by make and then by the shell.
6431 # Also, because we want to override the logic in subdir configure scripts to
6432 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6433 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6434 ${program_transform_name}
6435 EOF_SED
6436 gcc_transform_name=`cat conftestsed.out`
6437 rm -f conftestsed.out
6438 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6439 if test "$silent" = yes; then
6440   baseargs="$baseargs --silent"
6441 fi
6442
6443 # For the build-side libraries, we just need to pretend we're native,
6444 # and not use the same cache file.  Multilibs are neither needed nor
6445 # desired.
6446 build_configargs="--cache-file=../config.cache ${baseargs}"
6447
6448 # For host modules, accept cache file option, or specification as blank.
6449 case "${cache_file}" in
6450 "") # empty
6451   cache_file_option="" ;;
6452 /* | [A-Za-z]:[\\/]* ) # absolute path
6453   cache_file_option="--cache-file=${cache_file}" ;;
6454 *) # relative path
6455   cache_file_option="--cache-file=../${cache_file}" ;;
6456 esac
6457
6458 # Host dirs don't like to share a cache file either, horribly enough.
6459 # This seems to be due to autoconf 2.5x stupidity.
6460 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6461
6462 target_configargs=${baseargs}
6463
6464 # Passing a --with-cross-host argument lets the target libraries know
6465 # whether they are being built with a cross-compiler or being built
6466 # native.  However, it would be better to use other mechanisms to make the
6467 # sorts of decisions they want to make on this basis.  Please consider
6468 # this option to be deprecated.  FIXME.
6469 if test x${is_cross_compiler} = xyes ; then
6470   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6471 fi
6472
6473 # Default to --enable-multilib.
6474 if test x${enable_multilib} = x ; then
6475   target_configargs="--enable-multilib ${target_configargs}"
6476 fi
6477
6478 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6479 # changed from the earlier setting of with_newlib.
6480 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6481   target_configargs="--with-newlib ${target_configargs}"
6482 fi
6483
6484 # Different target subdirs use different values of certain variables
6485 # (notably CXX).  Worse, multilibs use *lots* of different values.
6486 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6487 # it doesn't automatically accept command-line overrides of them.
6488 # This means it's not safe for target subdirs to share a cache file,
6489 # which is disgusting, but there you have it.  Hopefully this can be
6490 # fixed in future.  It's still worthwhile to use a cache file for each
6491 # directory.  I think.
6492
6493 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6494 # We need to pass --target, as newer autoconf's requires consistency
6495 # for target_alias and gcc doesn't manage it consistently.
6496 target_configargs="--cache-file=./config.cache ${target_configargs}"
6497
6498 FLAGS_FOR_TARGET=
6499 case " $target_configdirs " in
6500  *" newlib "*)
6501   case " $target_configargs " in
6502   *" --with-newlib "*)
6503    case "$target" in
6504    *-cygwin*)
6505      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' ;;
6506    esac
6507
6508    # If we're not building GCC, don't discard standard headers.
6509    if test -d ${srcdir}/gcc; then
6510      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6511
6512      if test "${build}" != "${host}"; then
6513        # On Canadian crosses, CC_FOR_TARGET will have already been set
6514        # by `configure', so we won't have an opportunity to add -Bgcc/
6515        # to it.  This is right: we don't want to search that directory
6516        # for binaries, but we want the header files in there, so add
6517        # them explicitly.
6518        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6519
6520        # Someone might think of using the pre-installed headers on
6521        # Canadian crosses, in case the installed compiler is not fully
6522        # compatible with the compiler being built.  In this case, it
6523        # would be better to flag an error than risking having
6524        # incompatible object files being constructed.  We can't
6525        # guarantee that an error will be flagged, but let's hope the
6526        # compiler will do it, when presented with incompatible header
6527        # files.
6528      fi
6529    fi
6530
6531    case "${target}-${is_cross_compiler}" in
6532    i[3456789]86-*-linux*-no)
6533       # Here host == target, so we don't need to build gcc,
6534       # so we don't want to discard standard headers.
6535       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6536       ;;
6537    *)
6538       # If we're building newlib, use its generic headers last, but search
6539       # for any libc-related directories first (so make it the last -B
6540       # switch).
6541       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6542
6543       # If we're building libgloss, find the startup file, simulator library
6544       # and linker script.
6545       case " $target_configdirs " in
6546         *" libgloss "*)
6547         # Look for startup file, simulator library and maybe linker script.
6548         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6549         # Look for libnosys.a in case the target needs it.
6550         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6551         # Most targets have the linker script in the source directory.
6552         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6553         ;;
6554       esac
6555       ;;
6556    esac
6557    ;;
6558   esac
6559   ;;
6560 esac
6561 case "$target" in
6562 *-mingw*)
6563   # Can't be handled as Cygwin above since Mingw does not use newlib.
6564   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' ;;
6565 esac
6566
6567 # Allow the user to override the flags for
6568 # our build compiler if desired.
6569 if test x"${build}" = x"${host}" ; then
6570   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6571   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6572   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6573 fi
6574
6575 # On Canadian crosses, we'll be searching the right directories for
6576 # the previously-installed cross compiler, so don't bother to add
6577 # flags for directories within the install tree of the compiler
6578 # being built; programs in there won't even run.
6579 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6580   # Search for pre-installed headers if nothing else fits.
6581   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6582 fi
6583
6584 if test "x${use_gnu_ld}" = x &&
6585    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6586   # Arrange for us to find uninstalled linker scripts.
6587   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6588 fi
6589
6590 # Search for other target-specific linker scripts and such.
6591 case "${target}" in
6592   mep*)
6593     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6594     ;;
6595 esac
6596
6597 # Makefile fragments.
6598 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6599 do
6600   eval fragval=\$$frag
6601   if test $fragval != /dev/null; then
6602     eval $frag=${srcdir}/$fragval
6603   fi
6604 done
6605
6606
6607
6608
6609
6610 # Miscellanea: directories, flags, etc.
6611
6612
6613
6614
6615
6616
6617
6618
6619 # Build module lists & subconfigure args.
6620
6621
6622
6623 # Host module lists & subconfigure args.
6624
6625
6626
6627 # Target module lists & subconfigure args.
6628
6629
6630
6631 # Build tools.
6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649 # Generate default definitions for YACC, M4, LEX and other programs that run
6650 # on the build machine.  These are used if the Makefile can't locate these
6651 # programs in objdir.
6652 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6653
6654 for ac_prog in 'bison -y' byacc yacc
6655 do
6656   # Extract the first word of "$ac_prog", so it can be a program name with args.
6657 set dummy $ac_prog; ac_word=$2
6658 echo "$as_me:$LINENO: checking for $ac_word" >&5
6659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6660 if test "${ac_cv_prog_YACC+set}" = set; then
6661   echo $ECHO_N "(cached) $ECHO_C" >&6
6662 else
6663   if test -n "$YACC"; then
6664   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6665 else
6666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6667 for as_dir in $PATH
6668 do
6669   IFS=$as_save_IFS
6670   test -z "$as_dir" && as_dir=.
6671   for ac_exec_ext in '' $ac_executable_extensions; do
6672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6673     ac_cv_prog_YACC="$ac_prog"
6674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6675     break 2
6676   fi
6677 done
6678 done
6679
6680 fi
6681 fi
6682 YACC=$ac_cv_prog_YACC
6683 if test -n "$YACC"; then
6684   echo "$as_me:$LINENO: result: $YACC" >&5
6685 echo "${ECHO_T}$YACC" >&6
6686 else
6687   echo "$as_me:$LINENO: result: no" >&5
6688 echo "${ECHO_T}no" >&6
6689 fi
6690
6691   test -n "$YACC" && break
6692 done
6693 test -n "$YACC" || YACC="$MISSING bison -y"
6694
6695 case " $build_configdirs " in
6696   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6697   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6698 esac
6699
6700 for ac_prog in bison
6701 do
6702   # Extract the first word of "$ac_prog", so it can be a program name with args.
6703 set dummy $ac_prog; ac_word=$2
6704 echo "$as_me:$LINENO: checking for $ac_word" >&5
6705 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6706 if test "${ac_cv_prog_BISON+set}" = set; then
6707   echo $ECHO_N "(cached) $ECHO_C" >&6
6708 else
6709   if test -n "$BISON"; then
6710   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6711 else
6712 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6713 for as_dir in $PATH
6714 do
6715   IFS=$as_save_IFS
6716   test -z "$as_dir" && as_dir=.
6717   for ac_exec_ext in '' $ac_executable_extensions; do
6718   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6719     ac_cv_prog_BISON="$ac_prog"
6720     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6721     break 2
6722   fi
6723 done
6724 done
6725
6726 fi
6727 fi
6728 BISON=$ac_cv_prog_BISON
6729 if test -n "$BISON"; then
6730   echo "$as_me:$LINENO: result: $BISON" >&5
6731 echo "${ECHO_T}$BISON" >&6
6732 else
6733   echo "$as_me:$LINENO: result: no" >&5
6734 echo "${ECHO_T}no" >&6
6735 fi
6736
6737   test -n "$BISON" && break
6738 done
6739 test -n "$BISON" || BISON="$MISSING bison"
6740
6741 case " $build_configdirs " in
6742   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6743 esac
6744
6745 for ac_prog in gm4 gnum4 m4
6746 do
6747   # Extract the first word of "$ac_prog", so it can be a program name with args.
6748 set dummy $ac_prog; ac_word=$2
6749 echo "$as_me:$LINENO: checking for $ac_word" >&5
6750 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6751 if test "${ac_cv_prog_M4+set}" = set; then
6752   echo $ECHO_N "(cached) $ECHO_C" >&6
6753 else
6754   if test -n "$M4"; then
6755   ac_cv_prog_M4="$M4" # Let the user override the test.
6756 else
6757 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6758 for as_dir in $PATH
6759 do
6760   IFS=$as_save_IFS
6761   test -z "$as_dir" && as_dir=.
6762   for ac_exec_ext in '' $ac_executable_extensions; do
6763   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6764     ac_cv_prog_M4="$ac_prog"
6765     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6766     break 2
6767   fi
6768 done
6769 done
6770
6771 fi
6772 fi
6773 M4=$ac_cv_prog_M4
6774 if test -n "$M4"; then
6775   echo "$as_me:$LINENO: result: $M4" >&5
6776 echo "${ECHO_T}$M4" >&6
6777 else
6778   echo "$as_me:$LINENO: result: no" >&5
6779 echo "${ECHO_T}no" >&6
6780 fi
6781
6782   test -n "$M4" && break
6783 done
6784 test -n "$M4" || M4="$MISSING m4"
6785
6786 case " $build_configdirs " in
6787   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6788 esac
6789
6790 for ac_prog in flex lex
6791 do
6792   # Extract the first word of "$ac_prog", so it can be a program name with args.
6793 set dummy $ac_prog; ac_word=$2
6794 echo "$as_me:$LINENO: checking for $ac_word" >&5
6795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6796 if test "${ac_cv_prog_LEX+set}" = set; then
6797   echo $ECHO_N "(cached) $ECHO_C" >&6
6798 else
6799   if test -n "$LEX"; then
6800   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6801 else
6802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6803 for as_dir in $PATH
6804 do
6805   IFS=$as_save_IFS
6806   test -z "$as_dir" && as_dir=.
6807   for ac_exec_ext in '' $ac_executable_extensions; do
6808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6809     ac_cv_prog_LEX="$ac_prog"
6810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6811     break 2
6812   fi
6813 done
6814 done
6815
6816 fi
6817 fi
6818 LEX=$ac_cv_prog_LEX
6819 if test -n "$LEX"; then
6820   echo "$as_me:$LINENO: result: $LEX" >&5
6821 echo "${ECHO_T}$LEX" >&6
6822 else
6823   echo "$as_me:$LINENO: result: no" >&5
6824 echo "${ECHO_T}no" >&6
6825 fi
6826
6827   test -n "$LEX" && break
6828 done
6829 test -n "$LEX" || LEX="$MISSING flex"
6830
6831 case " $build_configdirs " in
6832   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6833   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6834 esac
6835
6836 for ac_prog in flex
6837 do
6838   # Extract the first word of "$ac_prog", so it can be a program name with args.
6839 set dummy $ac_prog; ac_word=$2
6840 echo "$as_me:$LINENO: checking for $ac_word" >&5
6841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6842 if test "${ac_cv_prog_FLEX+set}" = set; then
6843   echo $ECHO_N "(cached) $ECHO_C" >&6
6844 else
6845   if test -n "$FLEX"; then
6846   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6847 else
6848 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6849 for as_dir in $PATH
6850 do
6851   IFS=$as_save_IFS
6852   test -z "$as_dir" && as_dir=.
6853   for ac_exec_ext in '' $ac_executable_extensions; do
6854   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6855     ac_cv_prog_FLEX="$ac_prog"
6856     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6857     break 2
6858   fi
6859 done
6860 done
6861
6862 fi
6863 fi
6864 FLEX=$ac_cv_prog_FLEX
6865 if test -n "$FLEX"; then
6866   echo "$as_me:$LINENO: result: $FLEX" >&5
6867 echo "${ECHO_T}$FLEX" >&6
6868 else
6869   echo "$as_me:$LINENO: result: no" >&5
6870 echo "${ECHO_T}no" >&6
6871 fi
6872
6873   test -n "$FLEX" && break
6874 done
6875 test -n "$FLEX" || FLEX="$MISSING flex"
6876
6877 case " $build_configdirs " in
6878   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6879 esac
6880
6881 for ac_prog in makeinfo
6882 do
6883   # Extract the first word of "$ac_prog", so it can be a program name with args.
6884 set dummy $ac_prog; ac_word=$2
6885 echo "$as_me:$LINENO: checking for $ac_word" >&5
6886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6887 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6888   echo $ECHO_N "(cached) $ECHO_C" >&6
6889 else
6890   if test -n "$MAKEINFO"; then
6891   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6892 else
6893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6894 for as_dir in $PATH
6895 do
6896   IFS=$as_save_IFS
6897   test -z "$as_dir" && as_dir=.
6898   for ac_exec_ext in '' $ac_executable_extensions; do
6899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6900     ac_cv_prog_MAKEINFO="$ac_prog"
6901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6902     break 2
6903   fi
6904 done
6905 done
6906
6907 fi
6908 fi
6909 MAKEINFO=$ac_cv_prog_MAKEINFO
6910 if test -n "$MAKEINFO"; then
6911   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6912 echo "${ECHO_T}$MAKEINFO" >&6
6913 else
6914   echo "$as_me:$LINENO: result: no" >&5
6915 echo "${ECHO_T}no" >&6
6916 fi
6917
6918   test -n "$MAKEINFO" && break
6919 done
6920 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6921
6922 case " $build_configdirs " in
6923   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6924   *)
6925
6926     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6927     # higher, else we use the "missing" dummy.
6928     if ${MAKEINFO} --version \
6929        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6930       :
6931     else
6932       MAKEINFO="$MISSING makeinfo"
6933     fi
6934     ;;
6935
6936 esac
6937
6938 # FIXME: expect and dejagnu may become build tools?
6939
6940 for ac_prog in expect
6941 do
6942   # Extract the first word of "$ac_prog", so it can be a program name with args.
6943 set dummy $ac_prog; ac_word=$2
6944 echo "$as_me:$LINENO: checking for $ac_word" >&5
6945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6946 if test "${ac_cv_prog_EXPECT+set}" = set; then
6947   echo $ECHO_N "(cached) $ECHO_C" >&6
6948 else
6949   if test -n "$EXPECT"; then
6950   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6951 else
6952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6953 for as_dir in $PATH
6954 do
6955   IFS=$as_save_IFS
6956   test -z "$as_dir" && as_dir=.
6957   for ac_exec_ext in '' $ac_executable_extensions; do
6958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6959     ac_cv_prog_EXPECT="$ac_prog"
6960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6961     break 2
6962   fi
6963 done
6964 done
6965
6966 fi
6967 fi
6968 EXPECT=$ac_cv_prog_EXPECT
6969 if test -n "$EXPECT"; then
6970   echo "$as_me:$LINENO: result: $EXPECT" >&5
6971 echo "${ECHO_T}$EXPECT" >&6
6972 else
6973   echo "$as_me:$LINENO: result: no" >&5
6974 echo "${ECHO_T}no" >&6
6975 fi
6976
6977   test -n "$EXPECT" && break
6978 done
6979 test -n "$EXPECT" || EXPECT="expect"
6980
6981 case " $configdirs " in
6982   *" expect "*)
6983     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6984     ;;
6985 esac
6986
6987 for ac_prog in runtest
6988 do
6989   # Extract the first word of "$ac_prog", so it can be a program name with args.
6990 set dummy $ac_prog; ac_word=$2
6991 echo "$as_me:$LINENO: checking for $ac_word" >&5
6992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6993 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6994   echo $ECHO_N "(cached) $ECHO_C" >&6
6995 else
6996   if test -n "$RUNTEST"; then
6997   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6998 else
6999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7000 for as_dir in $PATH
7001 do
7002   IFS=$as_save_IFS
7003   test -z "$as_dir" && as_dir=.
7004   for ac_exec_ext in '' $ac_executable_extensions; do
7005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7006     ac_cv_prog_RUNTEST="$ac_prog"
7007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7008     break 2
7009   fi
7010 done
7011 done
7012
7013 fi
7014 fi
7015 RUNTEST=$ac_cv_prog_RUNTEST
7016 if test -n "$RUNTEST"; then
7017   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7018 echo "${ECHO_T}$RUNTEST" >&6
7019 else
7020   echo "$as_me:$LINENO: result: no" >&5
7021 echo "${ECHO_T}no" >&6
7022 fi
7023
7024   test -n "$RUNTEST" && break
7025 done
7026 test -n "$RUNTEST" || RUNTEST="runtest"
7027
7028 case " $configdirs " in
7029   *" dejagnu "*)
7030     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7031     ;;
7032 esac
7033
7034
7035 # Host tools.
7036 ncn_tool_prefix=
7037 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7038 ncn_target_tool_prefix=
7039 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7040
7041
7042
7043 if test -n "$AR"; then
7044   ac_cv_prog_AR=$AR
7045 elif test -n "$ac_cv_prog_AR"; then
7046   AR=$ac_cv_prog_AR
7047 fi
7048
7049 if test -n "$ac_cv_prog_AR"; then
7050   for ncn_progname in ar; do
7051     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7052 set dummy ${ncn_progname}; ac_word=$2
7053 echo "$as_me:$LINENO: checking for $ac_word" >&5
7054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7055 if test "${ac_cv_prog_AR+set}" = set; then
7056   echo $ECHO_N "(cached) $ECHO_C" >&6
7057 else
7058   if test -n "$AR"; then
7059   ac_cv_prog_AR="$AR" # Let the user override the test.
7060 else
7061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7062 for as_dir in $PATH
7063 do
7064   IFS=$as_save_IFS
7065   test -z "$as_dir" && as_dir=.
7066   for ac_exec_ext in '' $ac_executable_extensions; do
7067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7068     ac_cv_prog_AR="${ncn_progname}"
7069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7070     break 2
7071   fi
7072 done
7073 done
7074
7075 fi
7076 fi
7077 AR=$ac_cv_prog_AR
7078 if test -n "$AR"; then
7079   echo "$as_me:$LINENO: result: $AR" >&5
7080 echo "${ECHO_T}$AR" >&6
7081 else
7082   echo "$as_me:$LINENO: result: no" >&5
7083 echo "${ECHO_T}no" >&6
7084 fi
7085
7086   done
7087 fi
7088
7089 for ncn_progname in ar; do
7090   if test -n "$ncn_tool_prefix"; then
7091     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7092 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7093 echo "$as_me:$LINENO: checking for $ac_word" >&5
7094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7095 if test "${ac_cv_prog_AR+set}" = set; then
7096   echo $ECHO_N "(cached) $ECHO_C" >&6
7097 else
7098   if test -n "$AR"; then
7099   ac_cv_prog_AR="$AR" # Let the user override the test.
7100 else
7101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7102 for as_dir in $PATH
7103 do
7104   IFS=$as_save_IFS
7105   test -z "$as_dir" && as_dir=.
7106   for ac_exec_ext in '' $ac_executable_extensions; do
7107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7108     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7110     break 2
7111   fi
7112 done
7113 done
7114
7115 fi
7116 fi
7117 AR=$ac_cv_prog_AR
7118 if test -n "$AR"; then
7119   echo "$as_me:$LINENO: result: $AR" >&5
7120 echo "${ECHO_T}$AR" >&6
7121 else
7122   echo "$as_me:$LINENO: result: no" >&5
7123 echo "${ECHO_T}no" >&6
7124 fi
7125
7126   fi
7127   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7128     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7129 set dummy ${ncn_progname}; ac_word=$2
7130 echo "$as_me:$LINENO: checking for $ac_word" >&5
7131 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7132 if test "${ac_cv_prog_AR+set}" = set; then
7133   echo $ECHO_N "(cached) $ECHO_C" >&6
7134 else
7135   if test -n "$AR"; then
7136   ac_cv_prog_AR="$AR" # Let the user override the test.
7137 else
7138 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7139 for as_dir in $PATH
7140 do
7141   IFS=$as_save_IFS
7142   test -z "$as_dir" && as_dir=.
7143   for ac_exec_ext in '' $ac_executable_extensions; do
7144   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7145     ac_cv_prog_AR="${ncn_progname}"
7146     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7147     break 2
7148   fi
7149 done
7150 done
7151
7152 fi
7153 fi
7154 AR=$ac_cv_prog_AR
7155 if test -n "$AR"; then
7156   echo "$as_me:$LINENO: result: $AR" >&5
7157 echo "${ECHO_T}$AR" >&6
7158 else
7159   echo "$as_me:$LINENO: result: no" >&5
7160 echo "${ECHO_T}no" >&6
7161 fi
7162
7163   fi
7164   test -n "$ac_cv_prog_AR" && break
7165 done
7166
7167 if test -z "$ac_cv_prog_AR" ; then
7168   set dummy ar
7169   if test $build = $host ; then
7170     AR="$2"
7171   else
7172     AR="${ncn_tool_prefix}$2"
7173   fi
7174 fi
7175
7176
7177
7178 if test -n "$AS"; then
7179   ac_cv_prog_AS=$AS
7180 elif test -n "$ac_cv_prog_AS"; then
7181   AS=$ac_cv_prog_AS
7182 fi
7183
7184 if test -n "$ac_cv_prog_AS"; then
7185   for ncn_progname in as; do
7186     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7187 set dummy ${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_AS+set}" = set; then
7191   echo $ECHO_N "(cached) $ECHO_C" >&6
7192 else
7193   if test -n "$AS"; then
7194   ac_cv_prog_AS="$AS" # 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_AS="${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 AS=$ac_cv_prog_AS
7213 if test -n "$AS"; then
7214   echo "$as_me:$LINENO: result: $AS" >&5
7215 echo "${ECHO_T}$AS" >&6
7216 else
7217   echo "$as_me:$LINENO: result: no" >&5
7218 echo "${ECHO_T}no" >&6
7219 fi
7220
7221   done
7222 fi
7223
7224 for ncn_progname in as; do
7225   if test -n "$ncn_tool_prefix"; then
7226     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7227 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7228 echo "$as_me:$LINENO: checking for $ac_word" >&5
7229 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7230 if test "${ac_cv_prog_AS+set}" = set; then
7231   echo $ECHO_N "(cached) $ECHO_C" >&6
7232 else
7233   if test -n "$AS"; then
7234   ac_cv_prog_AS="$AS" # Let the user override the test.
7235 else
7236 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7237 for as_dir in $PATH
7238 do
7239   IFS=$as_save_IFS
7240   test -z "$as_dir" && as_dir=.
7241   for ac_exec_ext in '' $ac_executable_extensions; do
7242   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7243     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7244     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7245     break 2
7246   fi
7247 done
7248 done
7249
7250 fi
7251 fi
7252 AS=$ac_cv_prog_AS
7253 if test -n "$AS"; then
7254   echo "$as_me:$LINENO: result: $AS" >&5
7255 echo "${ECHO_T}$AS" >&6
7256 else
7257   echo "$as_me:$LINENO: result: no" >&5
7258 echo "${ECHO_T}no" >&6
7259 fi
7260
7261   fi
7262   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7263     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7264 set dummy ${ncn_progname}; ac_word=$2
7265 echo "$as_me:$LINENO: checking for $ac_word" >&5
7266 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7267 if test "${ac_cv_prog_AS+set}" = set; then
7268   echo $ECHO_N "(cached) $ECHO_C" >&6
7269 else
7270   if test -n "$AS"; then
7271   ac_cv_prog_AS="$AS" # Let the user override the test.
7272 else
7273 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7274 for as_dir in $PATH
7275 do
7276   IFS=$as_save_IFS
7277   test -z "$as_dir" && as_dir=.
7278   for ac_exec_ext in '' $ac_executable_extensions; do
7279   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7280     ac_cv_prog_AS="${ncn_progname}"
7281     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7282     break 2
7283   fi
7284 done
7285 done
7286
7287 fi
7288 fi
7289 AS=$ac_cv_prog_AS
7290 if test -n "$AS"; then
7291   echo "$as_me:$LINENO: result: $AS" >&5
7292 echo "${ECHO_T}$AS" >&6
7293 else
7294   echo "$as_me:$LINENO: result: no" >&5
7295 echo "${ECHO_T}no" >&6
7296 fi
7297
7298   fi
7299   test -n "$ac_cv_prog_AS" && break
7300 done
7301
7302 if test -z "$ac_cv_prog_AS" ; then
7303   set dummy as
7304   if test $build = $host ; then
7305     AS="$2"
7306   else
7307     AS="${ncn_tool_prefix}$2"
7308   fi
7309 fi
7310
7311
7312
7313 if test -n "$DLLTOOL"; then
7314   ac_cv_prog_DLLTOOL=$DLLTOOL
7315 elif test -n "$ac_cv_prog_DLLTOOL"; then
7316   DLLTOOL=$ac_cv_prog_DLLTOOL
7317 fi
7318
7319 if test -n "$ac_cv_prog_DLLTOOL"; then
7320   for ncn_progname in dlltool; do
7321     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7322 set dummy ${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_DLLTOOL+set}" = set; then
7326   echo $ECHO_N "(cached) $ECHO_C" >&6
7327 else
7328   if test -n "$DLLTOOL"; then
7329   ac_cv_prog_DLLTOOL="$DLLTOOL" # 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_DLLTOOL="${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 DLLTOOL=$ac_cv_prog_DLLTOOL
7348 if test -n "$DLLTOOL"; then
7349   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7350 echo "${ECHO_T}$DLLTOOL" >&6
7351 else
7352   echo "$as_me:$LINENO: result: no" >&5
7353 echo "${ECHO_T}no" >&6
7354 fi
7355
7356   done
7357 fi
7358
7359 for ncn_progname in dlltool; do
7360   if test -n "$ncn_tool_prefix"; then
7361     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7362 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7363 echo "$as_me:$LINENO: checking for $ac_word" >&5
7364 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7365 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7366   echo $ECHO_N "(cached) $ECHO_C" >&6
7367 else
7368   if test -n "$DLLTOOL"; then
7369   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7370 else
7371 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7372 for as_dir in $PATH
7373 do
7374   IFS=$as_save_IFS
7375   test -z "$as_dir" && as_dir=.
7376   for ac_exec_ext in '' $ac_executable_extensions; do
7377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7378     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7380     break 2
7381   fi
7382 done
7383 done
7384
7385 fi
7386 fi
7387 DLLTOOL=$ac_cv_prog_DLLTOOL
7388 if test -n "$DLLTOOL"; then
7389   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7390 echo "${ECHO_T}$DLLTOOL" >&6
7391 else
7392   echo "$as_me:$LINENO: result: no" >&5
7393 echo "${ECHO_T}no" >&6
7394 fi
7395
7396   fi
7397   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7398     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7399 set dummy ${ncn_progname}; ac_word=$2
7400 echo "$as_me:$LINENO: checking for $ac_word" >&5
7401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7402 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7403   echo $ECHO_N "(cached) $ECHO_C" >&6
7404 else
7405   if test -n "$DLLTOOL"; then
7406   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7407 else
7408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7409 for as_dir in $PATH
7410 do
7411   IFS=$as_save_IFS
7412   test -z "$as_dir" && as_dir=.
7413   for ac_exec_ext in '' $ac_executable_extensions; do
7414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7415     ac_cv_prog_DLLTOOL="${ncn_progname}"
7416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7417     break 2
7418   fi
7419 done
7420 done
7421
7422 fi
7423 fi
7424 DLLTOOL=$ac_cv_prog_DLLTOOL
7425 if test -n "$DLLTOOL"; then
7426   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7427 echo "${ECHO_T}$DLLTOOL" >&6
7428 else
7429   echo "$as_me:$LINENO: result: no" >&5
7430 echo "${ECHO_T}no" >&6
7431 fi
7432
7433   fi
7434   test -n "$ac_cv_prog_DLLTOOL" && break
7435 done
7436
7437 if test -z "$ac_cv_prog_DLLTOOL" ; then
7438   set dummy dlltool
7439   if test $build = $host ; then
7440     DLLTOOL="$2"
7441   else
7442     DLLTOOL="${ncn_tool_prefix}$2"
7443   fi
7444 fi
7445
7446
7447
7448 if test -n "$LD"; then
7449   ac_cv_prog_LD=$LD
7450 elif test -n "$ac_cv_prog_LD"; then
7451   LD=$ac_cv_prog_LD
7452 fi
7453
7454 if test -n "$ac_cv_prog_LD"; then
7455   for ncn_progname in ld; do
7456     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7457 set dummy ${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_LD+set}" = set; then
7461   echo $ECHO_N "(cached) $ECHO_C" >&6
7462 else
7463   if test -n "$LD"; then
7464   ac_cv_prog_LD="$LD" # 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_LD="${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 LD=$ac_cv_prog_LD
7483 if test -n "$LD"; then
7484   echo "$as_me:$LINENO: result: $LD" >&5
7485 echo "${ECHO_T}$LD" >&6
7486 else
7487   echo "$as_me:$LINENO: result: no" >&5
7488 echo "${ECHO_T}no" >&6
7489 fi
7490
7491   done
7492 fi
7493
7494 for ncn_progname in ld; do
7495   if test -n "$ncn_tool_prefix"; then
7496     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7497 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7498 echo "$as_me:$LINENO: checking for $ac_word" >&5
7499 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7500 if test "${ac_cv_prog_LD+set}" = set; then
7501   echo $ECHO_N "(cached) $ECHO_C" >&6
7502 else
7503   if test -n "$LD"; then
7504   ac_cv_prog_LD="$LD" # Let the user override the test.
7505 else
7506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7507 for as_dir in $PATH
7508 do
7509   IFS=$as_save_IFS
7510   test -z "$as_dir" && as_dir=.
7511   for ac_exec_ext in '' $ac_executable_extensions; do
7512   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7513     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7514     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7515     break 2
7516   fi
7517 done
7518 done
7519
7520 fi
7521 fi
7522 LD=$ac_cv_prog_LD
7523 if test -n "$LD"; then
7524   echo "$as_me:$LINENO: result: $LD" >&5
7525 echo "${ECHO_T}$LD" >&6
7526 else
7527   echo "$as_me:$LINENO: result: no" >&5
7528 echo "${ECHO_T}no" >&6
7529 fi
7530
7531   fi
7532   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7533     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7534 set dummy ${ncn_progname}; ac_word=$2
7535 echo "$as_me:$LINENO: checking for $ac_word" >&5
7536 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7537 if test "${ac_cv_prog_LD+set}" = set; then
7538   echo $ECHO_N "(cached) $ECHO_C" >&6
7539 else
7540   if test -n "$LD"; then
7541   ac_cv_prog_LD="$LD" # Let the user override the test.
7542 else
7543 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7544 for as_dir in $PATH
7545 do
7546   IFS=$as_save_IFS
7547   test -z "$as_dir" && as_dir=.
7548   for ac_exec_ext in '' $ac_executable_extensions; do
7549   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7550     ac_cv_prog_LD="${ncn_progname}"
7551     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7552     break 2
7553   fi
7554 done
7555 done
7556
7557 fi
7558 fi
7559 LD=$ac_cv_prog_LD
7560 if test -n "$LD"; then
7561   echo "$as_me:$LINENO: result: $LD" >&5
7562 echo "${ECHO_T}$LD" >&6
7563 else
7564   echo "$as_me:$LINENO: result: no" >&5
7565 echo "${ECHO_T}no" >&6
7566 fi
7567
7568   fi
7569   test -n "$ac_cv_prog_LD" && break
7570 done
7571
7572 if test -z "$ac_cv_prog_LD" ; then
7573   set dummy ld
7574   if test $build = $host ; then
7575     LD="$2"
7576   else
7577     LD="${ncn_tool_prefix}$2"
7578   fi
7579 fi
7580
7581
7582
7583 if test -n "$LIPO"; then
7584   ac_cv_prog_LIPO=$LIPO
7585 elif test -n "$ac_cv_prog_LIPO"; then
7586   LIPO=$ac_cv_prog_LIPO
7587 fi
7588
7589 if test -n "$ac_cv_prog_LIPO"; then
7590   for ncn_progname in lipo; do
7591     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7592 set dummy ${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_LIPO+set}" = set; then
7596   echo $ECHO_N "(cached) $ECHO_C" >&6
7597 else
7598   if test -n "$LIPO"; then
7599   ac_cv_prog_LIPO="$LIPO" # 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_LIPO="${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 LIPO=$ac_cv_prog_LIPO
7618 if test -n "$LIPO"; then
7619   echo "$as_me:$LINENO: result: $LIPO" >&5
7620 echo "${ECHO_T}$LIPO" >&6
7621 else
7622   echo "$as_me:$LINENO: result: no" >&5
7623 echo "${ECHO_T}no" >&6
7624 fi
7625
7626   done
7627 fi
7628
7629 for ncn_progname in lipo; do
7630   if test -n "$ncn_tool_prefix"; then
7631     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7632 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7633 echo "$as_me:$LINENO: checking for $ac_word" >&5
7634 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7635 if test "${ac_cv_prog_LIPO+set}" = set; then
7636   echo $ECHO_N "(cached) $ECHO_C" >&6
7637 else
7638   if test -n "$LIPO"; then
7639   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7640 else
7641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7642 for as_dir in $PATH
7643 do
7644   IFS=$as_save_IFS
7645   test -z "$as_dir" && as_dir=.
7646   for ac_exec_ext in '' $ac_executable_extensions; do
7647   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7648     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7649     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7650     break 2
7651   fi
7652 done
7653 done
7654
7655 fi
7656 fi
7657 LIPO=$ac_cv_prog_LIPO
7658 if test -n "$LIPO"; then
7659   echo "$as_me:$LINENO: result: $LIPO" >&5
7660 echo "${ECHO_T}$LIPO" >&6
7661 else
7662   echo "$as_me:$LINENO: result: no" >&5
7663 echo "${ECHO_T}no" >&6
7664 fi
7665
7666   fi
7667   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7668     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7669 set dummy ${ncn_progname}; ac_word=$2
7670 echo "$as_me:$LINENO: checking for $ac_word" >&5
7671 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7672 if test "${ac_cv_prog_LIPO+set}" = set; then
7673   echo $ECHO_N "(cached) $ECHO_C" >&6
7674 else
7675   if test -n "$LIPO"; then
7676   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7677 else
7678 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7679 for as_dir in $PATH
7680 do
7681   IFS=$as_save_IFS
7682   test -z "$as_dir" && as_dir=.
7683   for ac_exec_ext in '' $ac_executable_extensions; do
7684   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7685     ac_cv_prog_LIPO="${ncn_progname}"
7686     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7687     break 2
7688   fi
7689 done
7690 done
7691
7692 fi
7693 fi
7694 LIPO=$ac_cv_prog_LIPO
7695 if test -n "$LIPO"; then
7696   echo "$as_me:$LINENO: result: $LIPO" >&5
7697 echo "${ECHO_T}$LIPO" >&6
7698 else
7699   echo "$as_me:$LINENO: result: no" >&5
7700 echo "${ECHO_T}no" >&6
7701 fi
7702
7703   fi
7704   test -n "$ac_cv_prog_LIPO" && break
7705 done
7706
7707 if test -z "$ac_cv_prog_LIPO" ; then
7708   set dummy lipo
7709   if test $build = $host ; then
7710     LIPO="$2"
7711   else
7712     LIPO="${ncn_tool_prefix}$2"
7713   fi
7714 fi
7715
7716
7717
7718 if test -n "$NM"; then
7719   ac_cv_prog_NM=$NM
7720 elif test -n "$ac_cv_prog_NM"; then
7721   NM=$ac_cv_prog_NM
7722 fi
7723
7724 if test -n "$ac_cv_prog_NM"; then
7725   for ncn_progname in nm; do
7726     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7727 set dummy ${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_NM+set}" = set; then
7731   echo $ECHO_N "(cached) $ECHO_C" >&6
7732 else
7733   if test -n "$NM"; then
7734   ac_cv_prog_NM="$NM" # 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_NM="${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 NM=$ac_cv_prog_NM
7753 if test -n "$NM"; then
7754   echo "$as_me:$LINENO: result: $NM" >&5
7755 echo "${ECHO_T}$NM" >&6
7756 else
7757   echo "$as_me:$LINENO: result: no" >&5
7758 echo "${ECHO_T}no" >&6
7759 fi
7760
7761   done
7762 fi
7763
7764 for ncn_progname in nm; do
7765   if test -n "$ncn_tool_prefix"; then
7766     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7767 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7768 echo "$as_me:$LINENO: checking for $ac_word" >&5
7769 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7770 if test "${ac_cv_prog_NM+set}" = set; then
7771   echo $ECHO_N "(cached) $ECHO_C" >&6
7772 else
7773   if test -n "$NM"; then
7774   ac_cv_prog_NM="$NM" # Let the user override the test.
7775 else
7776 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7777 for as_dir in $PATH
7778 do
7779   IFS=$as_save_IFS
7780   test -z "$as_dir" && as_dir=.
7781   for ac_exec_ext in '' $ac_executable_extensions; do
7782   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7783     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7784     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7785     break 2
7786   fi
7787 done
7788 done
7789
7790 fi
7791 fi
7792 NM=$ac_cv_prog_NM
7793 if test -n "$NM"; then
7794   echo "$as_me:$LINENO: result: $NM" >&5
7795 echo "${ECHO_T}$NM" >&6
7796 else
7797   echo "$as_me:$LINENO: result: no" >&5
7798 echo "${ECHO_T}no" >&6
7799 fi
7800
7801   fi
7802   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7803     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7804 set dummy ${ncn_progname}; ac_word=$2
7805 echo "$as_me:$LINENO: checking for $ac_word" >&5
7806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7807 if test "${ac_cv_prog_NM+set}" = set; then
7808   echo $ECHO_N "(cached) $ECHO_C" >&6
7809 else
7810   if test -n "$NM"; then
7811   ac_cv_prog_NM="$NM" # Let the user override the test.
7812 else
7813 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7814 for as_dir in $PATH
7815 do
7816   IFS=$as_save_IFS
7817   test -z "$as_dir" && as_dir=.
7818   for ac_exec_ext in '' $ac_executable_extensions; do
7819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7820     ac_cv_prog_NM="${ncn_progname}"
7821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7822     break 2
7823   fi
7824 done
7825 done
7826
7827 fi
7828 fi
7829 NM=$ac_cv_prog_NM
7830 if test -n "$NM"; then
7831   echo "$as_me:$LINENO: result: $NM" >&5
7832 echo "${ECHO_T}$NM" >&6
7833 else
7834   echo "$as_me:$LINENO: result: no" >&5
7835 echo "${ECHO_T}no" >&6
7836 fi
7837
7838   fi
7839   test -n "$ac_cv_prog_NM" && break
7840 done
7841
7842 if test -z "$ac_cv_prog_NM" ; then
7843   set dummy nm
7844   if test $build = $host ; then
7845     NM="$2"
7846   else
7847     NM="${ncn_tool_prefix}$2"
7848   fi
7849 fi
7850
7851
7852
7853 if test -n "$RANLIB"; then
7854   ac_cv_prog_RANLIB=$RANLIB
7855 elif test -n "$ac_cv_prog_RANLIB"; then
7856   RANLIB=$ac_cv_prog_RANLIB
7857 fi
7858
7859 if test -n "$ac_cv_prog_RANLIB"; then
7860   for ncn_progname in ranlib; do
7861     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7862 set dummy ${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_RANLIB+set}" = set; then
7866   echo $ECHO_N "(cached) $ECHO_C" >&6
7867 else
7868   if test -n "$RANLIB"; then
7869   ac_cv_prog_RANLIB="$RANLIB" # 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_RANLIB="${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 RANLIB=$ac_cv_prog_RANLIB
7888 if test -n "$RANLIB"; then
7889   echo "$as_me:$LINENO: result: $RANLIB" >&5
7890 echo "${ECHO_T}$RANLIB" >&6
7891 else
7892   echo "$as_me:$LINENO: result: no" >&5
7893 echo "${ECHO_T}no" >&6
7894 fi
7895
7896   done
7897 fi
7898
7899 for ncn_progname in ranlib; do
7900   if test -n "$ncn_tool_prefix"; then
7901     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7902 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7903 echo "$as_me:$LINENO: checking for $ac_word" >&5
7904 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7905 if test "${ac_cv_prog_RANLIB+set}" = set; then
7906   echo $ECHO_N "(cached) $ECHO_C" >&6
7907 else
7908   if test -n "$RANLIB"; then
7909   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7910 else
7911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7912 for as_dir in $PATH
7913 do
7914   IFS=$as_save_IFS
7915   test -z "$as_dir" && as_dir=.
7916   for ac_exec_ext in '' $ac_executable_extensions; do
7917   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7918     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7919     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7920     break 2
7921   fi
7922 done
7923 done
7924
7925 fi
7926 fi
7927 RANLIB=$ac_cv_prog_RANLIB
7928 if test -n "$RANLIB"; then
7929   echo "$as_me:$LINENO: result: $RANLIB" >&5
7930 echo "${ECHO_T}$RANLIB" >&6
7931 else
7932   echo "$as_me:$LINENO: result: no" >&5
7933 echo "${ECHO_T}no" >&6
7934 fi
7935
7936   fi
7937   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7938     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7939 set dummy ${ncn_progname}; ac_word=$2
7940 echo "$as_me:$LINENO: checking for $ac_word" >&5
7941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7942 if test "${ac_cv_prog_RANLIB+set}" = set; then
7943   echo $ECHO_N "(cached) $ECHO_C" >&6
7944 else
7945   if test -n "$RANLIB"; then
7946   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7947 else
7948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7949 for as_dir in $PATH
7950 do
7951   IFS=$as_save_IFS
7952   test -z "$as_dir" && as_dir=.
7953   for ac_exec_ext in '' $ac_executable_extensions; do
7954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7955     ac_cv_prog_RANLIB="${ncn_progname}"
7956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7957     break 2
7958   fi
7959 done
7960 done
7961
7962 fi
7963 fi
7964 RANLIB=$ac_cv_prog_RANLIB
7965 if test -n "$RANLIB"; then
7966   echo "$as_me:$LINENO: result: $RANLIB" >&5
7967 echo "${ECHO_T}$RANLIB" >&6
7968 else
7969   echo "$as_me:$LINENO: result: no" >&5
7970 echo "${ECHO_T}no" >&6
7971 fi
7972
7973   fi
7974   test -n "$ac_cv_prog_RANLIB" && break
7975 done
7976
7977 if test -z "$ac_cv_prog_RANLIB" ; then
7978   RANLIB=":"
7979 fi
7980
7981
7982
7983 if test -n "$STRIP"; then
7984   ac_cv_prog_STRIP=$STRIP
7985 elif test -n "$ac_cv_prog_STRIP"; then
7986   STRIP=$ac_cv_prog_STRIP
7987 fi
7988
7989 if test -n "$ac_cv_prog_STRIP"; then
7990   for ncn_progname in strip; do
7991     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7992 set dummy ${ncn_progname}; ac_word=$2
7993 echo "$as_me:$LINENO: checking for $ac_word" >&5
7994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7995 if test "${ac_cv_prog_STRIP+set}" = set; then
7996   echo $ECHO_N "(cached) $ECHO_C" >&6
7997 else
7998   if test -n "$STRIP"; then
7999   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8000 else
8001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8002 for as_dir in $PATH
8003 do
8004   IFS=$as_save_IFS
8005   test -z "$as_dir" && as_dir=.
8006   for ac_exec_ext in '' $ac_executable_extensions; do
8007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8008     ac_cv_prog_STRIP="${ncn_progname}"
8009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8010     break 2
8011   fi
8012 done
8013 done
8014
8015 fi
8016 fi
8017 STRIP=$ac_cv_prog_STRIP
8018 if test -n "$STRIP"; then
8019   echo "$as_me:$LINENO: result: $STRIP" >&5
8020 echo "${ECHO_T}$STRIP" >&6
8021 else
8022   echo "$as_me:$LINENO: result: no" >&5
8023 echo "${ECHO_T}no" >&6
8024 fi
8025
8026   done
8027 fi
8028
8029 for ncn_progname in strip; do
8030   if test -n "$ncn_tool_prefix"; then
8031     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8032 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8033 echo "$as_me:$LINENO: checking for $ac_word" >&5
8034 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8035 if test "${ac_cv_prog_STRIP+set}" = set; then
8036   echo $ECHO_N "(cached) $ECHO_C" >&6
8037 else
8038   if test -n "$STRIP"; then
8039   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8040 else
8041 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8042 for as_dir in $PATH
8043 do
8044   IFS=$as_save_IFS
8045   test -z "$as_dir" && as_dir=.
8046   for ac_exec_ext in '' $ac_executable_extensions; do
8047   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8048     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8049     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8050     break 2
8051   fi
8052 done
8053 done
8054
8055 fi
8056 fi
8057 STRIP=$ac_cv_prog_STRIP
8058 if test -n "$STRIP"; then
8059   echo "$as_me:$LINENO: result: $STRIP" >&5
8060 echo "${ECHO_T}$STRIP" >&6
8061 else
8062   echo "$as_me:$LINENO: result: no" >&5
8063 echo "${ECHO_T}no" >&6
8064 fi
8065
8066   fi
8067   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8068     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8069 set dummy ${ncn_progname}; ac_word=$2
8070 echo "$as_me:$LINENO: checking for $ac_word" >&5
8071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8072 if test "${ac_cv_prog_STRIP+set}" = set; then
8073   echo $ECHO_N "(cached) $ECHO_C" >&6
8074 else
8075   if test -n "$STRIP"; then
8076   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8077 else
8078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8079 for as_dir in $PATH
8080 do
8081   IFS=$as_save_IFS
8082   test -z "$as_dir" && as_dir=.
8083   for ac_exec_ext in '' $ac_executable_extensions; do
8084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8085     ac_cv_prog_STRIP="${ncn_progname}"
8086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8087     break 2
8088   fi
8089 done
8090 done
8091
8092 fi
8093 fi
8094 STRIP=$ac_cv_prog_STRIP
8095 if test -n "$STRIP"; then
8096   echo "$as_me:$LINENO: result: $STRIP" >&5
8097 echo "${ECHO_T}$STRIP" >&6
8098 else
8099   echo "$as_me:$LINENO: result: no" >&5
8100 echo "${ECHO_T}no" >&6
8101 fi
8102
8103   fi
8104   test -n "$ac_cv_prog_STRIP" && break
8105 done
8106
8107 if test -z "$ac_cv_prog_STRIP" ; then
8108   STRIP=":"
8109 fi
8110
8111
8112
8113 if test -n "$WINDRES"; then
8114   ac_cv_prog_WINDRES=$WINDRES
8115 elif test -n "$ac_cv_prog_WINDRES"; then
8116   WINDRES=$ac_cv_prog_WINDRES
8117 fi
8118
8119 if test -n "$ac_cv_prog_WINDRES"; then
8120   for ncn_progname in windres; do
8121     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8122 set dummy ${ncn_progname}; ac_word=$2
8123 echo "$as_me:$LINENO: checking for $ac_word" >&5
8124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8125 if test "${ac_cv_prog_WINDRES+set}" = set; then
8126   echo $ECHO_N "(cached) $ECHO_C" >&6
8127 else
8128   if test -n "$WINDRES"; then
8129   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8130 else
8131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8132 for as_dir in $PATH
8133 do
8134   IFS=$as_save_IFS
8135   test -z "$as_dir" && as_dir=.
8136   for ac_exec_ext in '' $ac_executable_extensions; do
8137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8138     ac_cv_prog_WINDRES="${ncn_progname}"
8139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8140     break 2
8141   fi
8142 done
8143 done
8144
8145 fi
8146 fi
8147 WINDRES=$ac_cv_prog_WINDRES
8148 if test -n "$WINDRES"; then
8149   echo "$as_me:$LINENO: result: $WINDRES" >&5
8150 echo "${ECHO_T}$WINDRES" >&6
8151 else
8152   echo "$as_me:$LINENO: result: no" >&5
8153 echo "${ECHO_T}no" >&6
8154 fi
8155
8156   done
8157 fi
8158
8159 for ncn_progname in windres; do
8160   if test -n "$ncn_tool_prefix"; then
8161     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8162 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8163 echo "$as_me:$LINENO: checking for $ac_word" >&5
8164 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8165 if test "${ac_cv_prog_WINDRES+set}" = set; then
8166   echo $ECHO_N "(cached) $ECHO_C" >&6
8167 else
8168   if test -n "$WINDRES"; then
8169   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8170 else
8171 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8172 for as_dir in $PATH
8173 do
8174   IFS=$as_save_IFS
8175   test -z "$as_dir" && as_dir=.
8176   for ac_exec_ext in '' $ac_executable_extensions; do
8177   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8178     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8179     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8180     break 2
8181   fi
8182 done
8183 done
8184
8185 fi
8186 fi
8187 WINDRES=$ac_cv_prog_WINDRES
8188 if test -n "$WINDRES"; then
8189   echo "$as_me:$LINENO: result: $WINDRES" >&5
8190 echo "${ECHO_T}$WINDRES" >&6
8191 else
8192   echo "$as_me:$LINENO: result: no" >&5
8193 echo "${ECHO_T}no" >&6
8194 fi
8195
8196   fi
8197   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8198     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8199 set dummy ${ncn_progname}; ac_word=$2
8200 echo "$as_me:$LINENO: checking for $ac_word" >&5
8201 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8202 if test "${ac_cv_prog_WINDRES+set}" = set; then
8203   echo $ECHO_N "(cached) $ECHO_C" >&6
8204 else
8205   if test -n "$WINDRES"; then
8206   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8207 else
8208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8209 for as_dir in $PATH
8210 do
8211   IFS=$as_save_IFS
8212   test -z "$as_dir" && as_dir=.
8213   for ac_exec_ext in '' $ac_executable_extensions; do
8214   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8215     ac_cv_prog_WINDRES="${ncn_progname}"
8216     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8217     break 2
8218   fi
8219 done
8220 done
8221
8222 fi
8223 fi
8224 WINDRES=$ac_cv_prog_WINDRES
8225 if test -n "$WINDRES"; then
8226   echo "$as_me:$LINENO: result: $WINDRES" >&5
8227 echo "${ECHO_T}$WINDRES" >&6
8228 else
8229   echo "$as_me:$LINENO: result: no" >&5
8230 echo "${ECHO_T}no" >&6
8231 fi
8232
8233   fi
8234   test -n "$ac_cv_prog_WINDRES" && break
8235 done
8236
8237 if test -z "$ac_cv_prog_WINDRES" ; then
8238   set dummy windres
8239   if test $build = $host ; then
8240     WINDRES="$2"
8241   else
8242     WINDRES="${ncn_tool_prefix}$2"
8243   fi
8244 fi
8245
8246
8247
8248 if test -n "$WINDMC"; then
8249   ac_cv_prog_WINDMC=$WINDMC
8250 elif test -n "$ac_cv_prog_WINDMC"; then
8251   WINDMC=$ac_cv_prog_WINDMC
8252 fi
8253
8254 if test -n "$ac_cv_prog_WINDMC"; then
8255   for ncn_progname in windmc; do
8256     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8257 set dummy ${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_WINDMC+set}" = set; then
8261   echo $ECHO_N "(cached) $ECHO_C" >&6
8262 else
8263   if test -n "$WINDMC"; then
8264   ac_cv_prog_WINDMC="$WINDMC" # 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_WINDMC="${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 WINDMC=$ac_cv_prog_WINDMC
8283 if test -n "$WINDMC"; then
8284   echo "$as_me:$LINENO: result: $WINDMC" >&5
8285 echo "${ECHO_T}$WINDMC" >&6
8286 else
8287   echo "$as_me:$LINENO: result: no" >&5
8288 echo "${ECHO_T}no" >&6
8289 fi
8290
8291   done
8292 fi
8293
8294 for ncn_progname in windmc; do
8295   if test -n "$ncn_tool_prefix"; then
8296     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8297 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8298 echo "$as_me:$LINENO: checking for $ac_word" >&5
8299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8300 if test "${ac_cv_prog_WINDMC+set}" = set; then
8301   echo $ECHO_N "(cached) $ECHO_C" >&6
8302 else
8303   if test -n "$WINDMC"; then
8304   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8305 else
8306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8307 for as_dir in $PATH
8308 do
8309   IFS=$as_save_IFS
8310   test -z "$as_dir" && as_dir=.
8311   for ac_exec_ext in '' $ac_executable_extensions; do
8312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8313     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8315     break 2
8316   fi
8317 done
8318 done
8319
8320 fi
8321 fi
8322 WINDMC=$ac_cv_prog_WINDMC
8323 if test -n "$WINDMC"; then
8324   echo "$as_me:$LINENO: result: $WINDMC" >&5
8325 echo "${ECHO_T}$WINDMC" >&6
8326 else
8327   echo "$as_me:$LINENO: result: no" >&5
8328 echo "${ECHO_T}no" >&6
8329 fi
8330
8331   fi
8332   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8333     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8334 set dummy ${ncn_progname}; ac_word=$2
8335 echo "$as_me:$LINENO: checking for $ac_word" >&5
8336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8337 if test "${ac_cv_prog_WINDMC+set}" = set; then
8338   echo $ECHO_N "(cached) $ECHO_C" >&6
8339 else
8340   if test -n "$WINDMC"; then
8341   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8342 else
8343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8344 for as_dir in $PATH
8345 do
8346   IFS=$as_save_IFS
8347   test -z "$as_dir" && as_dir=.
8348   for ac_exec_ext in '' $ac_executable_extensions; do
8349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8350     ac_cv_prog_WINDMC="${ncn_progname}"
8351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8352     break 2
8353   fi
8354 done
8355 done
8356
8357 fi
8358 fi
8359 WINDMC=$ac_cv_prog_WINDMC
8360 if test -n "$WINDMC"; then
8361   echo "$as_me:$LINENO: result: $WINDMC" >&5
8362 echo "${ECHO_T}$WINDMC" >&6
8363 else
8364   echo "$as_me:$LINENO: result: no" >&5
8365 echo "${ECHO_T}no" >&6
8366 fi
8367
8368   fi
8369   test -n "$ac_cv_prog_WINDMC" && break
8370 done
8371
8372 if test -z "$ac_cv_prog_WINDMC" ; then
8373   set dummy windmc
8374   if test $build = $host ; then
8375     WINDMC="$2"
8376   else
8377     WINDMC="${ncn_tool_prefix}$2"
8378   fi
8379 fi
8380
8381
8382
8383 if test -n "$OBJCOPY"; then
8384   ac_cv_prog_OBJCOPY=$OBJCOPY
8385 elif test -n "$ac_cv_prog_OBJCOPY"; then
8386   OBJCOPY=$ac_cv_prog_OBJCOPY
8387 fi
8388
8389 if test -n "$ac_cv_prog_OBJCOPY"; then
8390   for ncn_progname in objcopy; do
8391     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8392 set dummy ${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_OBJCOPY+set}" = set; then
8396   echo $ECHO_N "(cached) $ECHO_C" >&6
8397 else
8398   if test -n "$OBJCOPY"; then
8399   ac_cv_prog_OBJCOPY="$OBJCOPY" # 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_OBJCOPY="${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 OBJCOPY=$ac_cv_prog_OBJCOPY
8418 if test -n "$OBJCOPY"; then
8419   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8420 echo "${ECHO_T}$OBJCOPY" >&6
8421 else
8422   echo "$as_me:$LINENO: result: no" >&5
8423 echo "${ECHO_T}no" >&6
8424 fi
8425
8426   done
8427 fi
8428
8429 for ncn_progname in objcopy; do
8430   if test -n "$ncn_tool_prefix"; then
8431     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8432 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8433 echo "$as_me:$LINENO: checking for $ac_word" >&5
8434 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8435 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8436   echo $ECHO_N "(cached) $ECHO_C" >&6
8437 else
8438   if test -n "$OBJCOPY"; then
8439   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8440 else
8441 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8442 for as_dir in $PATH
8443 do
8444   IFS=$as_save_IFS
8445   test -z "$as_dir" && as_dir=.
8446   for ac_exec_ext in '' $ac_executable_extensions; do
8447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8448     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8450     break 2
8451   fi
8452 done
8453 done
8454
8455 fi
8456 fi
8457 OBJCOPY=$ac_cv_prog_OBJCOPY
8458 if test -n "$OBJCOPY"; then
8459   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8460 echo "${ECHO_T}$OBJCOPY" >&6
8461 else
8462   echo "$as_me:$LINENO: result: no" >&5
8463 echo "${ECHO_T}no" >&6
8464 fi
8465
8466   fi
8467   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8468     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8469 set dummy ${ncn_progname}; ac_word=$2
8470 echo "$as_me:$LINENO: checking for $ac_word" >&5
8471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8472 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8473   echo $ECHO_N "(cached) $ECHO_C" >&6
8474 else
8475   if test -n "$OBJCOPY"; then
8476   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8477 else
8478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8479 for as_dir in $PATH
8480 do
8481   IFS=$as_save_IFS
8482   test -z "$as_dir" && as_dir=.
8483   for ac_exec_ext in '' $ac_executable_extensions; do
8484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8485     ac_cv_prog_OBJCOPY="${ncn_progname}"
8486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8487     break 2
8488   fi
8489 done
8490 done
8491
8492 fi
8493 fi
8494 OBJCOPY=$ac_cv_prog_OBJCOPY
8495 if test -n "$OBJCOPY"; then
8496   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8497 echo "${ECHO_T}$OBJCOPY" >&6
8498 else
8499   echo "$as_me:$LINENO: result: no" >&5
8500 echo "${ECHO_T}no" >&6
8501 fi
8502
8503   fi
8504   test -n "$ac_cv_prog_OBJCOPY" && break
8505 done
8506
8507 if test -z "$ac_cv_prog_OBJCOPY" ; then
8508   set dummy objcopy
8509   if test $build = $host ; then
8510     OBJCOPY="$2"
8511   else
8512     OBJCOPY="${ncn_tool_prefix}$2"
8513   fi
8514 fi
8515
8516
8517
8518 if test -n "$OBJDUMP"; then
8519   ac_cv_prog_OBJDUMP=$OBJDUMP
8520 elif test -n "$ac_cv_prog_OBJDUMP"; then
8521   OBJDUMP=$ac_cv_prog_OBJDUMP
8522 fi
8523
8524 if test -n "$ac_cv_prog_OBJDUMP"; then
8525   for ncn_progname in objdump; do
8526     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8527 set dummy ${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_OBJDUMP+set}" = set; then
8531   echo $ECHO_N "(cached) $ECHO_C" >&6
8532 else
8533   if test -n "$OBJDUMP"; then
8534   ac_cv_prog_OBJDUMP="$OBJDUMP" # 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_OBJDUMP="${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 OBJDUMP=$ac_cv_prog_OBJDUMP
8553 if test -n "$OBJDUMP"; then
8554   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8555 echo "${ECHO_T}$OBJDUMP" >&6
8556 else
8557   echo "$as_me:$LINENO: result: no" >&5
8558 echo "${ECHO_T}no" >&6
8559 fi
8560
8561   done
8562 fi
8563
8564 for ncn_progname in objdump; do
8565   if test -n "$ncn_tool_prefix"; then
8566     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8567 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8568 echo "$as_me:$LINENO: checking for $ac_word" >&5
8569 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8570 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8571   echo $ECHO_N "(cached) $ECHO_C" >&6
8572 else
8573   if test -n "$OBJDUMP"; then
8574   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8575 else
8576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8577 for as_dir in $PATH
8578 do
8579   IFS=$as_save_IFS
8580   test -z "$as_dir" && as_dir=.
8581   for ac_exec_ext in '' $ac_executable_extensions; do
8582   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8583     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8584     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8585     break 2
8586   fi
8587 done
8588 done
8589
8590 fi
8591 fi
8592 OBJDUMP=$ac_cv_prog_OBJDUMP
8593 if test -n "$OBJDUMP"; then
8594   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8595 echo "${ECHO_T}$OBJDUMP" >&6
8596 else
8597   echo "$as_me:$LINENO: result: no" >&5
8598 echo "${ECHO_T}no" >&6
8599 fi
8600
8601   fi
8602   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8603     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8604 set dummy ${ncn_progname}; ac_word=$2
8605 echo "$as_me:$LINENO: checking for $ac_word" >&5
8606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8607 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8608   echo $ECHO_N "(cached) $ECHO_C" >&6
8609 else
8610   if test -n "$OBJDUMP"; then
8611   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8612 else
8613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8614 for as_dir in $PATH
8615 do
8616   IFS=$as_save_IFS
8617   test -z "$as_dir" && as_dir=.
8618   for ac_exec_ext in '' $ac_executable_extensions; do
8619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8620     ac_cv_prog_OBJDUMP="${ncn_progname}"
8621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8622     break 2
8623   fi
8624 done
8625 done
8626
8627 fi
8628 fi
8629 OBJDUMP=$ac_cv_prog_OBJDUMP
8630 if test -n "$OBJDUMP"; then
8631   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8632 echo "${ECHO_T}$OBJDUMP" >&6
8633 else
8634   echo "$as_me:$LINENO: result: no" >&5
8635 echo "${ECHO_T}no" >&6
8636 fi
8637
8638   fi
8639   test -n "$ac_cv_prog_OBJDUMP" && break
8640 done
8641
8642 if test -z "$ac_cv_prog_OBJDUMP" ; then
8643   set dummy objdump
8644   if test $build = $host ; then
8645     OBJDUMP="$2"
8646   else
8647     OBJDUMP="${ncn_tool_prefix}$2"
8648   fi
8649 fi
8650
8651
8652
8653
8654
8655
8656 # Target tools.
8657
8658 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8659 if test "${with_build_time_tools+set}" = set; then
8660   withval="$with_build_time_tools"
8661   case x"$withval" in
8662      x/*) ;;
8663      *)
8664        with_build_time_tools=
8665        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8666 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8667        ;;
8668    esac
8669 else
8670   with_build_time_tools=
8671 fi;
8672
8673
8674
8675 if test -n "$CC_FOR_TARGET"; then
8676   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8677 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8678   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8679 fi
8680
8681 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8682   for ncn_progname in cc gcc; do
8683     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8684 set dummy ${ncn_progname}; ac_word=$2
8685 echo "$as_me:$LINENO: checking for $ac_word" >&5
8686 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8687 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8688   echo $ECHO_N "(cached) $ECHO_C" >&6
8689 else
8690   if test -n "$CC_FOR_TARGET"; then
8691   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8692 else
8693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8694 for as_dir in $PATH
8695 do
8696   IFS=$as_save_IFS
8697   test -z "$as_dir" && as_dir=.
8698   for ac_exec_ext in '' $ac_executable_extensions; do
8699   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8700     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8701     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8702     break 2
8703   fi
8704 done
8705 done
8706
8707 fi
8708 fi
8709 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8710 if test -n "$CC_FOR_TARGET"; then
8711   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8712 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8713 else
8714   echo "$as_me:$LINENO: result: no" >&5
8715 echo "${ECHO_T}no" >&6
8716 fi
8717
8718   done
8719 fi
8720
8721 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8722   for ncn_progname in cc gcc; do
8723     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8724 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8725     if test -x $with_build_time_tools/${ncn_progname}; then
8726       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8727       echo "$as_me:$LINENO: result: yes" >&5
8728 echo "${ECHO_T}yes" >&6
8729       break
8730     else
8731       echo "$as_me:$LINENO: result: no" >&5
8732 echo "${ECHO_T}no" >&6
8733     fi
8734   done
8735 fi
8736
8737 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8738   for ncn_progname in cc gcc; do
8739     if test -n "$ncn_target_tool_prefix"; then
8740       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8741 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8742 echo "$as_me:$LINENO: checking for $ac_word" >&5
8743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8744 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8745   echo $ECHO_N "(cached) $ECHO_C" >&6
8746 else
8747   if test -n "$CC_FOR_TARGET"; then
8748   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8749 else
8750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8751 for as_dir in $PATH
8752 do
8753   IFS=$as_save_IFS
8754   test -z "$as_dir" && as_dir=.
8755   for ac_exec_ext in '' $ac_executable_extensions; do
8756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8757     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8759     break 2
8760   fi
8761 done
8762 done
8763
8764 fi
8765 fi
8766 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8767 if test -n "$CC_FOR_TARGET"; then
8768   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8769 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8770 else
8771   echo "$as_me:$LINENO: result: no" >&5
8772 echo "${ECHO_T}no" >&6
8773 fi
8774
8775     fi
8776     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8777       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8778 set dummy ${ncn_progname}; ac_word=$2
8779 echo "$as_me:$LINENO: checking for $ac_word" >&5
8780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8781 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8782   echo $ECHO_N "(cached) $ECHO_C" >&6
8783 else
8784   if test -n "$CC_FOR_TARGET"; then
8785   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8786 else
8787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8788 for as_dir in $PATH
8789 do
8790   IFS=$as_save_IFS
8791   test -z "$as_dir" && as_dir=.
8792   for ac_exec_ext in '' $ac_executable_extensions; do
8793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8794     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8796     break 2
8797   fi
8798 done
8799 done
8800
8801 fi
8802 fi
8803 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8804 if test -n "$CC_FOR_TARGET"; then
8805   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8806 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8807 else
8808   echo "$as_me:$LINENO: result: no" >&5
8809 echo "${ECHO_T}no" >&6
8810 fi
8811
8812     fi
8813     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8814   done
8815 fi
8816
8817 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8818   set dummy cc gcc
8819   if test $build = $target ; then
8820     CC_FOR_TARGET="$2"
8821   else
8822     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8823   fi
8824 else
8825   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8826 fi
8827
8828
8829
8830 if test -n "$CXX_FOR_TARGET"; then
8831   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8832 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8833   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8834 fi
8835
8836 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8837   for ncn_progname in c++ g++ cxx gxx; do
8838     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8839 set dummy ${ncn_progname}; ac_word=$2
8840 echo "$as_me:$LINENO: checking for $ac_word" >&5
8841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8842 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8843   echo $ECHO_N "(cached) $ECHO_C" >&6
8844 else
8845   if test -n "$CXX_FOR_TARGET"; then
8846   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8847 else
8848 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8849 for as_dir in $PATH
8850 do
8851   IFS=$as_save_IFS
8852   test -z "$as_dir" && as_dir=.
8853   for ac_exec_ext in '' $ac_executable_extensions; do
8854   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8855     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8856     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8857     break 2
8858   fi
8859 done
8860 done
8861
8862 fi
8863 fi
8864 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8865 if test -n "$CXX_FOR_TARGET"; then
8866   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8867 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8868 else
8869   echo "$as_me:$LINENO: result: no" >&5
8870 echo "${ECHO_T}no" >&6
8871 fi
8872
8873   done
8874 fi
8875
8876 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8877   for ncn_progname in c++ g++ cxx gxx; do
8878     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8879 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8880     if test -x $with_build_time_tools/${ncn_progname}; then
8881       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8882       echo "$as_me:$LINENO: result: yes" >&5
8883 echo "${ECHO_T}yes" >&6
8884       break
8885     else
8886       echo "$as_me:$LINENO: result: no" >&5
8887 echo "${ECHO_T}no" >&6
8888     fi
8889   done
8890 fi
8891
8892 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8893   for ncn_progname in c++ g++ cxx gxx; do
8894     if test -n "$ncn_target_tool_prefix"; then
8895       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8896 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8897 echo "$as_me:$LINENO: checking for $ac_word" >&5
8898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8899 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8900   echo $ECHO_N "(cached) $ECHO_C" >&6
8901 else
8902   if test -n "$CXX_FOR_TARGET"; then
8903   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8904 else
8905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8906 for as_dir in $PATH
8907 do
8908   IFS=$as_save_IFS
8909   test -z "$as_dir" && as_dir=.
8910   for ac_exec_ext in '' $ac_executable_extensions; do
8911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8912     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8914     break 2
8915   fi
8916 done
8917 done
8918
8919 fi
8920 fi
8921 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8922 if test -n "$CXX_FOR_TARGET"; then
8923   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8924 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8925 else
8926   echo "$as_me:$LINENO: result: no" >&5
8927 echo "${ECHO_T}no" >&6
8928 fi
8929
8930     fi
8931     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8932       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8933 set dummy ${ncn_progname}; ac_word=$2
8934 echo "$as_me:$LINENO: checking for $ac_word" >&5
8935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8936 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8937   echo $ECHO_N "(cached) $ECHO_C" >&6
8938 else
8939   if test -n "$CXX_FOR_TARGET"; then
8940   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8941 else
8942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8943 for as_dir in $PATH
8944 do
8945   IFS=$as_save_IFS
8946   test -z "$as_dir" && as_dir=.
8947   for ac_exec_ext in '' $ac_executable_extensions; do
8948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8949     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8951     break 2
8952   fi
8953 done
8954 done
8955
8956 fi
8957 fi
8958 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8959 if test -n "$CXX_FOR_TARGET"; then
8960   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8961 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8962 else
8963   echo "$as_me:$LINENO: result: no" >&5
8964 echo "${ECHO_T}no" >&6
8965 fi
8966
8967     fi
8968     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8969   done
8970 fi
8971
8972 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8973   set dummy c++ g++ cxx gxx
8974   if test $build = $target ; then
8975     CXX_FOR_TARGET="$2"
8976   else
8977     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8978   fi
8979 else
8980   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8981 fi
8982
8983
8984
8985 if test -n "$GCC_FOR_TARGET"; then
8986   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8987 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8988   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8989 fi
8990
8991 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8992   for ncn_progname in gcc; do
8993     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8994 set dummy ${ncn_progname}; ac_word=$2
8995 echo "$as_me:$LINENO: checking for $ac_word" >&5
8996 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8997 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8998   echo $ECHO_N "(cached) $ECHO_C" >&6
8999 else
9000   if test -n "$GCC_FOR_TARGET"; then
9001   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9002 else
9003 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9004 for as_dir in $PATH
9005 do
9006   IFS=$as_save_IFS
9007   test -z "$as_dir" && as_dir=.
9008   for ac_exec_ext in '' $ac_executable_extensions; do
9009   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9010     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9011     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9012     break 2
9013   fi
9014 done
9015 done
9016
9017 fi
9018 fi
9019 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9020 if test -n "$GCC_FOR_TARGET"; then
9021   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9022 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9023 else
9024   echo "$as_me:$LINENO: result: no" >&5
9025 echo "${ECHO_T}no" >&6
9026 fi
9027
9028   done
9029 fi
9030
9031 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9032   for ncn_progname in gcc; do
9033     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9034 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9035     if test -x $with_build_time_tools/${ncn_progname}; then
9036       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9037       echo "$as_me:$LINENO: result: yes" >&5
9038 echo "${ECHO_T}yes" >&6
9039       break
9040     else
9041       echo "$as_me:$LINENO: result: no" >&5
9042 echo "${ECHO_T}no" >&6
9043     fi
9044   done
9045 fi
9046
9047 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9048   for ncn_progname in gcc; do
9049     if test -n "$ncn_target_tool_prefix"; then
9050       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9051 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9052 echo "$as_me:$LINENO: checking for $ac_word" >&5
9053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9054 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9055   echo $ECHO_N "(cached) $ECHO_C" >&6
9056 else
9057   if test -n "$GCC_FOR_TARGET"; then
9058   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9059 else
9060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9061 for as_dir in $PATH
9062 do
9063   IFS=$as_save_IFS
9064   test -z "$as_dir" && as_dir=.
9065   for ac_exec_ext in '' $ac_executable_extensions; do
9066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9067     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9069     break 2
9070   fi
9071 done
9072 done
9073
9074 fi
9075 fi
9076 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9077 if test -n "$GCC_FOR_TARGET"; then
9078   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9079 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9080 else
9081   echo "$as_me:$LINENO: result: no" >&5
9082 echo "${ECHO_T}no" >&6
9083 fi
9084
9085     fi
9086     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9087       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9088 set dummy ${ncn_progname}; ac_word=$2
9089 echo "$as_me:$LINENO: checking for $ac_word" >&5
9090 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9091 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9092   echo $ECHO_N "(cached) $ECHO_C" >&6
9093 else
9094   if test -n "$GCC_FOR_TARGET"; then
9095   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9096 else
9097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9098 for as_dir in $PATH
9099 do
9100   IFS=$as_save_IFS
9101   test -z "$as_dir" && as_dir=.
9102   for ac_exec_ext in '' $ac_executable_extensions; do
9103   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9104     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9105     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9106     break 2
9107   fi
9108 done
9109 done
9110
9111 fi
9112 fi
9113 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9114 if test -n "$GCC_FOR_TARGET"; then
9115   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9116 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9117 else
9118   echo "$as_me:$LINENO: result: no" >&5
9119 echo "${ECHO_T}no" >&6
9120 fi
9121
9122     fi
9123     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9124   done
9125 fi
9126
9127 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9128   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9129 else
9130   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9131 fi
9132
9133
9134
9135 if test -n "$GCJ_FOR_TARGET"; then
9136   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9137 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9138   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9139 fi
9140
9141 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9142   for ncn_progname in gcj; do
9143     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9144 set dummy ${ncn_progname}; ac_word=$2
9145 echo "$as_me:$LINENO: checking for $ac_word" >&5
9146 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9147 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9148   echo $ECHO_N "(cached) $ECHO_C" >&6
9149 else
9150   if test -n "$GCJ_FOR_TARGET"; then
9151   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9152 else
9153 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9154 for as_dir in $PATH
9155 do
9156   IFS=$as_save_IFS
9157   test -z "$as_dir" && as_dir=.
9158   for ac_exec_ext in '' $ac_executable_extensions; do
9159   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9160     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9161     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9162     break 2
9163   fi
9164 done
9165 done
9166
9167 fi
9168 fi
9169 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9170 if test -n "$GCJ_FOR_TARGET"; then
9171   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9172 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9173 else
9174   echo "$as_me:$LINENO: result: no" >&5
9175 echo "${ECHO_T}no" >&6
9176 fi
9177
9178   done
9179 fi
9180
9181 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9182   for ncn_progname in gcj; do
9183     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9184 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9185     if test -x $with_build_time_tools/${ncn_progname}; then
9186       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9187       echo "$as_me:$LINENO: result: yes" >&5
9188 echo "${ECHO_T}yes" >&6
9189       break
9190     else
9191       echo "$as_me:$LINENO: result: no" >&5
9192 echo "${ECHO_T}no" >&6
9193     fi
9194   done
9195 fi
9196
9197 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9198   for ncn_progname in gcj; do
9199     if test -n "$ncn_target_tool_prefix"; then
9200       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9201 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9202 echo "$as_me:$LINENO: checking for $ac_word" >&5
9203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9204 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9205   echo $ECHO_N "(cached) $ECHO_C" >&6
9206 else
9207   if test -n "$GCJ_FOR_TARGET"; then
9208   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9209 else
9210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9211 for as_dir in $PATH
9212 do
9213   IFS=$as_save_IFS
9214   test -z "$as_dir" && as_dir=.
9215   for ac_exec_ext in '' $ac_executable_extensions; do
9216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9217     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9219     break 2
9220   fi
9221 done
9222 done
9223
9224 fi
9225 fi
9226 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9227 if test -n "$GCJ_FOR_TARGET"; then
9228   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9229 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9230 else
9231   echo "$as_me:$LINENO: result: no" >&5
9232 echo "${ECHO_T}no" >&6
9233 fi
9234
9235     fi
9236     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9237       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9238 set dummy ${ncn_progname}; ac_word=$2
9239 echo "$as_me:$LINENO: checking for $ac_word" >&5
9240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9241 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9242   echo $ECHO_N "(cached) $ECHO_C" >&6
9243 else
9244   if test -n "$GCJ_FOR_TARGET"; then
9245   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9246 else
9247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9248 for as_dir in $PATH
9249 do
9250   IFS=$as_save_IFS
9251   test -z "$as_dir" && as_dir=.
9252   for ac_exec_ext in '' $ac_executable_extensions; do
9253   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9254     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9255     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9256     break 2
9257   fi
9258 done
9259 done
9260
9261 fi
9262 fi
9263 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9264 if test -n "$GCJ_FOR_TARGET"; then
9265   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9266 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9267 else
9268   echo "$as_me:$LINENO: result: no" >&5
9269 echo "${ECHO_T}no" >&6
9270 fi
9271
9272     fi
9273     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9274   done
9275 fi
9276
9277 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9278   set dummy gcj
9279   if test $build = $target ; then
9280     GCJ_FOR_TARGET="$2"
9281   else
9282     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9283   fi
9284 else
9285   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9286 fi
9287
9288
9289
9290 if test -n "$GFORTRAN_FOR_TARGET"; then
9291   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9292 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9293   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9294 fi
9295
9296 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9297   for ncn_progname in gfortran; do
9298     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9299 set dummy ${ncn_progname}; ac_word=$2
9300 echo "$as_me:$LINENO: checking for $ac_word" >&5
9301 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9302 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9303   echo $ECHO_N "(cached) $ECHO_C" >&6
9304 else
9305   if test -n "$GFORTRAN_FOR_TARGET"; then
9306   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9307 else
9308 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9309 for as_dir in $PATH
9310 do
9311   IFS=$as_save_IFS
9312   test -z "$as_dir" && as_dir=.
9313   for ac_exec_ext in '' $ac_executable_extensions; do
9314   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9315     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9316     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9317     break 2
9318   fi
9319 done
9320 done
9321
9322 fi
9323 fi
9324 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9325 if test -n "$GFORTRAN_FOR_TARGET"; then
9326   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9327 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9328 else
9329   echo "$as_me:$LINENO: result: no" >&5
9330 echo "${ECHO_T}no" >&6
9331 fi
9332
9333   done
9334 fi
9335
9336 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9337   for ncn_progname in gfortran; do
9338     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9339 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9340     if test -x $with_build_time_tools/${ncn_progname}; then
9341       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9342       echo "$as_me:$LINENO: result: yes" >&5
9343 echo "${ECHO_T}yes" >&6
9344       break
9345     else
9346       echo "$as_me:$LINENO: result: no" >&5
9347 echo "${ECHO_T}no" >&6
9348     fi
9349   done
9350 fi
9351
9352 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9353   for ncn_progname in gfortran; do
9354     if test -n "$ncn_target_tool_prefix"; then
9355       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9356 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9357 echo "$as_me:$LINENO: checking for $ac_word" >&5
9358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9359 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9360   echo $ECHO_N "(cached) $ECHO_C" >&6
9361 else
9362   if test -n "$GFORTRAN_FOR_TARGET"; then
9363   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9364 else
9365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9366 for as_dir in $PATH
9367 do
9368   IFS=$as_save_IFS
9369   test -z "$as_dir" && as_dir=.
9370   for ac_exec_ext in '' $ac_executable_extensions; do
9371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9372     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9374     break 2
9375   fi
9376 done
9377 done
9378
9379 fi
9380 fi
9381 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9382 if test -n "$GFORTRAN_FOR_TARGET"; then
9383   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9384 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9385 else
9386   echo "$as_me:$LINENO: result: no" >&5
9387 echo "${ECHO_T}no" >&6
9388 fi
9389
9390     fi
9391     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9392       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9393 set dummy ${ncn_progname}; ac_word=$2
9394 echo "$as_me:$LINENO: checking for $ac_word" >&5
9395 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9396 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9397   echo $ECHO_N "(cached) $ECHO_C" >&6
9398 else
9399   if test -n "$GFORTRAN_FOR_TARGET"; then
9400   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9401 else
9402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9403 for as_dir in $PATH
9404 do
9405   IFS=$as_save_IFS
9406   test -z "$as_dir" && as_dir=.
9407   for ac_exec_ext in '' $ac_executable_extensions; do
9408   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9409     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9410     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9411     break 2
9412   fi
9413 done
9414 done
9415
9416 fi
9417 fi
9418 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9419 if test -n "$GFORTRAN_FOR_TARGET"; then
9420   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9421 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9422 else
9423   echo "$as_me:$LINENO: result: no" >&5
9424 echo "${ECHO_T}no" >&6
9425 fi
9426
9427     fi
9428     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9429   done
9430 fi
9431
9432 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9433   set dummy gfortran
9434   if test $build = $target ; then
9435     GFORTRAN_FOR_TARGET="$2"
9436   else
9437     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9438   fi
9439 else
9440   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9441 fi
9442
9443
9444
9445 cat > conftest.c << \EOF
9446 #ifdef __GNUC__
9447   gcc_yay;
9448 #endif
9449 EOF
9450 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9451   have_gcc_for_target=yes
9452 else
9453   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9454   have_gcc_for_target=no
9455 fi
9456 rm conftest.c
9457
9458
9459
9460
9461 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9462   if test -n "$with_build_time_tools"; then
9463     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9464 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9465     if test -x $with_build_time_tools/ar; then
9466       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9467       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9468       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9469 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9470     else
9471       echo "$as_me:$LINENO: result: no" >&5
9472 echo "${ECHO_T}no" >&6
9473     fi
9474   elif test $build != $host && test $have_gcc_for_target = yes; then
9475     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9476     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9477     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9478   fi
9479 fi
9480 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9481   # Extract the first word of "ar", so it can be a program name with args.
9482 set dummy ar; ac_word=$2
9483 echo "$as_me:$LINENO: checking for $ac_word" >&5
9484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9485 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9486   echo $ECHO_N "(cached) $ECHO_C" >&6
9487 else
9488   case $AR_FOR_TARGET in
9489   [\\/]* | ?:[\\/]*)
9490   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9491   ;;
9492   *)
9493   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9494 for as_dir in $gcc_cv_tool_dirs
9495 do
9496   IFS=$as_save_IFS
9497   test -z "$as_dir" && as_dir=.
9498   for ac_exec_ext in '' $ac_executable_extensions; do
9499   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9500     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9501     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9502     break 2
9503   fi
9504 done
9505 done
9506
9507   ;;
9508 esac
9509 fi
9510 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9511
9512 if test -n "$AR_FOR_TARGET"; then
9513   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9514 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9515 else
9516   echo "$as_me:$LINENO: result: no" >&5
9517 echo "${ECHO_T}no" >&6
9518 fi
9519
9520 fi
9521 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9522
9523
9524 if test -n "$AR_FOR_TARGET"; then
9525   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9526 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9527   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9528 fi
9529
9530 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9531   for ncn_progname in ar; do
9532     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9533 set dummy ${ncn_progname}; ac_word=$2
9534 echo "$as_me:$LINENO: checking for $ac_word" >&5
9535 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9536 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9537   echo $ECHO_N "(cached) $ECHO_C" >&6
9538 else
9539   if test -n "$AR_FOR_TARGET"; then
9540   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9541 else
9542 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9543 for as_dir in $PATH
9544 do
9545   IFS=$as_save_IFS
9546   test -z "$as_dir" && as_dir=.
9547   for ac_exec_ext in '' $ac_executable_extensions; do
9548   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9549     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9550     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9551     break 2
9552   fi
9553 done
9554 done
9555
9556 fi
9557 fi
9558 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9559 if test -n "$AR_FOR_TARGET"; then
9560   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9561 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9562 else
9563   echo "$as_me:$LINENO: result: no" >&5
9564 echo "${ECHO_T}no" >&6
9565 fi
9566
9567   done
9568 fi
9569
9570 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9571   for ncn_progname in ar; do
9572     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9573 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9574     if test -x $with_build_time_tools/${ncn_progname}; then
9575       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9576       echo "$as_me:$LINENO: result: yes" >&5
9577 echo "${ECHO_T}yes" >&6
9578       break
9579     else
9580       echo "$as_me:$LINENO: result: no" >&5
9581 echo "${ECHO_T}no" >&6
9582     fi
9583   done
9584 fi
9585
9586 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9587   for ncn_progname in ar; do
9588     if test -n "$ncn_target_tool_prefix"; then
9589       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9590 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9591 echo "$as_me:$LINENO: checking for $ac_word" >&5
9592 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9593 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9594   echo $ECHO_N "(cached) $ECHO_C" >&6
9595 else
9596   if test -n "$AR_FOR_TARGET"; then
9597   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9598 else
9599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9600 for as_dir in $PATH
9601 do
9602   IFS=$as_save_IFS
9603   test -z "$as_dir" && as_dir=.
9604   for ac_exec_ext in '' $ac_executable_extensions; do
9605   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9606     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9607     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9608     break 2
9609   fi
9610 done
9611 done
9612
9613 fi
9614 fi
9615 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9616 if test -n "$AR_FOR_TARGET"; then
9617   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9618 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9619 else
9620   echo "$as_me:$LINENO: result: no" >&5
9621 echo "${ECHO_T}no" >&6
9622 fi
9623
9624     fi
9625     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9626       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9627 set dummy ${ncn_progname}; ac_word=$2
9628 echo "$as_me:$LINENO: checking for $ac_word" >&5
9629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9630 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9631   echo $ECHO_N "(cached) $ECHO_C" >&6
9632 else
9633   if test -n "$AR_FOR_TARGET"; then
9634   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9635 else
9636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9637 for as_dir in $PATH
9638 do
9639   IFS=$as_save_IFS
9640   test -z "$as_dir" && as_dir=.
9641   for ac_exec_ext in '' $ac_executable_extensions; do
9642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9643     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9645     break 2
9646   fi
9647 done
9648 done
9649
9650 fi
9651 fi
9652 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9653 if test -n "$AR_FOR_TARGET"; then
9654   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9655 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9656 else
9657   echo "$as_me:$LINENO: result: no" >&5
9658 echo "${ECHO_T}no" >&6
9659 fi
9660
9661     fi
9662     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9663   done
9664 fi
9665
9666 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9667   set dummy ar
9668   if test $build = $target ; then
9669     AR_FOR_TARGET="$2"
9670   else
9671     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9672   fi
9673 else
9674   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9675 fi
9676
9677 else
9678   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9679 fi
9680
9681
9682
9683
9684 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9685   if test -n "$with_build_time_tools"; then
9686     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9687 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9688     if test -x $with_build_time_tools/as; then
9689       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9690       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9691       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9692 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9693     else
9694       echo "$as_me:$LINENO: result: no" >&5
9695 echo "${ECHO_T}no" >&6
9696     fi
9697   elif test $build != $host && test $have_gcc_for_target = yes; then
9698     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9699     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9700     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9701   fi
9702 fi
9703 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9704   # Extract the first word of "as", so it can be a program name with args.
9705 set dummy as; ac_word=$2
9706 echo "$as_me:$LINENO: checking for $ac_word" >&5
9707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9708 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9709   echo $ECHO_N "(cached) $ECHO_C" >&6
9710 else
9711   case $AS_FOR_TARGET in
9712   [\\/]* | ?:[\\/]*)
9713   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9714   ;;
9715   *)
9716   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9717 for as_dir in $gcc_cv_tool_dirs
9718 do
9719   IFS=$as_save_IFS
9720   test -z "$as_dir" && as_dir=.
9721   for ac_exec_ext in '' $ac_executable_extensions; do
9722   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9723     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9724     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9725     break 2
9726   fi
9727 done
9728 done
9729
9730   ;;
9731 esac
9732 fi
9733 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9734
9735 if test -n "$AS_FOR_TARGET"; then
9736   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9737 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9738 else
9739   echo "$as_me:$LINENO: result: no" >&5
9740 echo "${ECHO_T}no" >&6
9741 fi
9742
9743 fi
9744 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9745
9746
9747 if test -n "$AS_FOR_TARGET"; then
9748   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9749 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9750   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9751 fi
9752
9753 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9754   for ncn_progname in as; do
9755     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9756 set dummy ${ncn_progname}; ac_word=$2
9757 echo "$as_me:$LINENO: checking for $ac_word" >&5
9758 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9759 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9760   echo $ECHO_N "(cached) $ECHO_C" >&6
9761 else
9762   if test -n "$AS_FOR_TARGET"; then
9763   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9764 else
9765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9766 for as_dir in $PATH
9767 do
9768   IFS=$as_save_IFS
9769   test -z "$as_dir" && as_dir=.
9770   for ac_exec_ext in '' $ac_executable_extensions; do
9771   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9772     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9773     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9774     break 2
9775   fi
9776 done
9777 done
9778
9779 fi
9780 fi
9781 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9782 if test -n "$AS_FOR_TARGET"; then
9783   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9784 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9785 else
9786   echo "$as_me:$LINENO: result: no" >&5
9787 echo "${ECHO_T}no" >&6
9788 fi
9789
9790   done
9791 fi
9792
9793 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9794   for ncn_progname in as; do
9795     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9796 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9797     if test -x $with_build_time_tools/${ncn_progname}; then
9798       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9799       echo "$as_me:$LINENO: result: yes" >&5
9800 echo "${ECHO_T}yes" >&6
9801       break
9802     else
9803       echo "$as_me:$LINENO: result: no" >&5
9804 echo "${ECHO_T}no" >&6
9805     fi
9806   done
9807 fi
9808
9809 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9810   for ncn_progname in as; do
9811     if test -n "$ncn_target_tool_prefix"; then
9812       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9813 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9814 echo "$as_me:$LINENO: checking for $ac_word" >&5
9815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9816 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9817   echo $ECHO_N "(cached) $ECHO_C" >&6
9818 else
9819   if test -n "$AS_FOR_TARGET"; then
9820   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9821 else
9822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9823 for as_dir in $PATH
9824 do
9825   IFS=$as_save_IFS
9826   test -z "$as_dir" && as_dir=.
9827   for ac_exec_ext in '' $ac_executable_extensions; do
9828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9829     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9831     break 2
9832   fi
9833 done
9834 done
9835
9836 fi
9837 fi
9838 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9839 if test -n "$AS_FOR_TARGET"; then
9840   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9841 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9842 else
9843   echo "$as_me:$LINENO: result: no" >&5
9844 echo "${ECHO_T}no" >&6
9845 fi
9846
9847     fi
9848     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9849       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9850 set dummy ${ncn_progname}; ac_word=$2
9851 echo "$as_me:$LINENO: checking for $ac_word" >&5
9852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9853 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9854   echo $ECHO_N "(cached) $ECHO_C" >&6
9855 else
9856   if test -n "$AS_FOR_TARGET"; then
9857   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9858 else
9859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9860 for as_dir in $PATH
9861 do
9862   IFS=$as_save_IFS
9863   test -z "$as_dir" && as_dir=.
9864   for ac_exec_ext in '' $ac_executable_extensions; do
9865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9866     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9868     break 2
9869   fi
9870 done
9871 done
9872
9873 fi
9874 fi
9875 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9876 if test -n "$AS_FOR_TARGET"; then
9877   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9878 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9879 else
9880   echo "$as_me:$LINENO: result: no" >&5
9881 echo "${ECHO_T}no" >&6
9882 fi
9883
9884     fi
9885     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9886   done
9887 fi
9888
9889 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9890   set dummy as
9891   if test $build = $target ; then
9892     AS_FOR_TARGET="$2"
9893   else
9894     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9895   fi
9896 else
9897   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9898 fi
9899
9900 else
9901   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9902 fi
9903
9904
9905
9906
9907 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9908   if test -n "$with_build_time_tools"; then
9909     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9910 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9911     if test -x $with_build_time_tools/dlltool; then
9912       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9913       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9914       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9915 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9916     else
9917       echo "$as_me:$LINENO: result: no" >&5
9918 echo "${ECHO_T}no" >&6
9919     fi
9920   elif test $build != $host && test $have_gcc_for_target = yes; then
9921     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9922     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9923     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9924   fi
9925 fi
9926 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9927   # Extract the first word of "dlltool", so it can be a program name with args.
9928 set dummy dlltool; ac_word=$2
9929 echo "$as_me:$LINENO: checking for $ac_word" >&5
9930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9931 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9932   echo $ECHO_N "(cached) $ECHO_C" >&6
9933 else
9934   case $DLLTOOL_FOR_TARGET in
9935   [\\/]* | ?:[\\/]*)
9936   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9937   ;;
9938   *)
9939   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9940 for as_dir in $gcc_cv_tool_dirs
9941 do
9942   IFS=$as_save_IFS
9943   test -z "$as_dir" && as_dir=.
9944   for ac_exec_ext in '' $ac_executable_extensions; do
9945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9946     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9948     break 2
9949   fi
9950 done
9951 done
9952
9953   ;;
9954 esac
9955 fi
9956 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9957
9958 if test -n "$DLLTOOL_FOR_TARGET"; then
9959   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9960 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9961 else
9962   echo "$as_me:$LINENO: result: no" >&5
9963 echo "${ECHO_T}no" >&6
9964 fi
9965
9966 fi
9967 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9968
9969
9970 if test -n "$DLLTOOL_FOR_TARGET"; then
9971   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9972 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9973   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9974 fi
9975
9976 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9977   for ncn_progname in dlltool; do
9978     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9979 set dummy ${ncn_progname}; ac_word=$2
9980 echo "$as_me:$LINENO: checking for $ac_word" >&5
9981 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9982 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9983   echo $ECHO_N "(cached) $ECHO_C" >&6
9984 else
9985   if test -n "$DLLTOOL_FOR_TARGET"; then
9986   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9987 else
9988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9989 for as_dir in $PATH
9990 do
9991   IFS=$as_save_IFS
9992   test -z "$as_dir" && as_dir=.
9993   for ac_exec_ext in '' $ac_executable_extensions; do
9994   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9995     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9997     break 2
9998   fi
9999 done
10000 done
10001
10002 fi
10003 fi
10004 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10005 if test -n "$DLLTOOL_FOR_TARGET"; then
10006   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10007 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10008 else
10009   echo "$as_me:$LINENO: result: no" >&5
10010 echo "${ECHO_T}no" >&6
10011 fi
10012
10013   done
10014 fi
10015
10016 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10017   for ncn_progname in dlltool; do
10018     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10019 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10020     if test -x $with_build_time_tools/${ncn_progname}; then
10021       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10022       echo "$as_me:$LINENO: result: yes" >&5
10023 echo "${ECHO_T}yes" >&6
10024       break
10025     else
10026       echo "$as_me:$LINENO: result: no" >&5
10027 echo "${ECHO_T}no" >&6
10028     fi
10029   done
10030 fi
10031
10032 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10033   for ncn_progname in dlltool; do
10034     if test -n "$ncn_target_tool_prefix"; then
10035       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10036 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10037 echo "$as_me:$LINENO: checking for $ac_word" >&5
10038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10039 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10040   echo $ECHO_N "(cached) $ECHO_C" >&6
10041 else
10042   if test -n "$DLLTOOL_FOR_TARGET"; then
10043   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10044 else
10045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10046 for as_dir in $PATH
10047 do
10048   IFS=$as_save_IFS
10049   test -z "$as_dir" && as_dir=.
10050   for ac_exec_ext in '' $ac_executable_extensions; do
10051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10052     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10054     break 2
10055   fi
10056 done
10057 done
10058
10059 fi
10060 fi
10061 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10062 if test -n "$DLLTOOL_FOR_TARGET"; then
10063   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10064 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10065 else
10066   echo "$as_me:$LINENO: result: no" >&5
10067 echo "${ECHO_T}no" >&6
10068 fi
10069
10070     fi
10071     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10072       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10073 set dummy ${ncn_progname}; ac_word=$2
10074 echo "$as_me:$LINENO: checking for $ac_word" >&5
10075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10076 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10077   echo $ECHO_N "(cached) $ECHO_C" >&6
10078 else
10079   if test -n "$DLLTOOL_FOR_TARGET"; then
10080   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10081 else
10082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10083 for as_dir in $PATH
10084 do
10085   IFS=$as_save_IFS
10086   test -z "$as_dir" && as_dir=.
10087   for ac_exec_ext in '' $ac_executable_extensions; do
10088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10089     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10091     break 2
10092   fi
10093 done
10094 done
10095
10096 fi
10097 fi
10098 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10099 if test -n "$DLLTOOL_FOR_TARGET"; then
10100   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10101 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10102 else
10103   echo "$as_me:$LINENO: result: no" >&5
10104 echo "${ECHO_T}no" >&6
10105 fi
10106
10107     fi
10108     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10109   done
10110 fi
10111
10112 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10113   set dummy dlltool
10114   if test $build = $target ; then
10115     DLLTOOL_FOR_TARGET="$2"
10116   else
10117     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10118   fi
10119 else
10120   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10121 fi
10122
10123 else
10124   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10125 fi
10126
10127
10128
10129
10130 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10131   if test -n "$with_build_time_tools"; then
10132     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10133 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10134     if test -x $with_build_time_tools/ld; then
10135       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10136       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10137       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10138 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10139     else
10140       echo "$as_me:$LINENO: result: no" >&5
10141 echo "${ECHO_T}no" >&6
10142     fi
10143   elif test $build != $host && test $have_gcc_for_target = yes; then
10144     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10145     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10146     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10147   fi
10148 fi
10149 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10150   # Extract the first word of "ld", so it can be a program name with args.
10151 set dummy ld; ac_word=$2
10152 echo "$as_me:$LINENO: checking for $ac_word" >&5
10153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10154 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10155   echo $ECHO_N "(cached) $ECHO_C" >&6
10156 else
10157   case $LD_FOR_TARGET in
10158   [\\/]* | ?:[\\/]*)
10159   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10160   ;;
10161   *)
10162   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10163 for as_dir in $gcc_cv_tool_dirs
10164 do
10165   IFS=$as_save_IFS
10166   test -z "$as_dir" && as_dir=.
10167   for ac_exec_ext in '' $ac_executable_extensions; do
10168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10169     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10171     break 2
10172   fi
10173 done
10174 done
10175
10176   ;;
10177 esac
10178 fi
10179 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10180
10181 if test -n "$LD_FOR_TARGET"; then
10182   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10183 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10184 else
10185   echo "$as_me:$LINENO: result: no" >&5
10186 echo "${ECHO_T}no" >&6
10187 fi
10188
10189 fi
10190 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10191
10192
10193 if test -n "$LD_FOR_TARGET"; then
10194   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10195 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10196   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10197 fi
10198
10199 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10200   for ncn_progname in ld; do
10201     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10202 set dummy ${ncn_progname}; ac_word=$2
10203 echo "$as_me:$LINENO: checking for $ac_word" >&5
10204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10205 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10206   echo $ECHO_N "(cached) $ECHO_C" >&6
10207 else
10208   if test -n "$LD_FOR_TARGET"; then
10209   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10210 else
10211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10212 for as_dir in $PATH
10213 do
10214   IFS=$as_save_IFS
10215   test -z "$as_dir" && as_dir=.
10216   for ac_exec_ext in '' $ac_executable_extensions; do
10217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10218     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10220     break 2
10221   fi
10222 done
10223 done
10224
10225 fi
10226 fi
10227 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10228 if test -n "$LD_FOR_TARGET"; then
10229   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10230 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10231 else
10232   echo "$as_me:$LINENO: result: no" >&5
10233 echo "${ECHO_T}no" >&6
10234 fi
10235
10236   done
10237 fi
10238
10239 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10240   for ncn_progname in ld; do
10241     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10242 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10243     if test -x $with_build_time_tools/${ncn_progname}; then
10244       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10245       echo "$as_me:$LINENO: result: yes" >&5
10246 echo "${ECHO_T}yes" >&6
10247       break
10248     else
10249       echo "$as_me:$LINENO: result: no" >&5
10250 echo "${ECHO_T}no" >&6
10251     fi
10252   done
10253 fi
10254
10255 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10256   for ncn_progname in ld; do
10257     if test -n "$ncn_target_tool_prefix"; then
10258       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10259 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10260 echo "$as_me:$LINENO: checking for $ac_word" >&5
10261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10262 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10263   echo $ECHO_N "(cached) $ECHO_C" >&6
10264 else
10265   if test -n "$LD_FOR_TARGET"; then
10266   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10267 else
10268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10269 for as_dir in $PATH
10270 do
10271   IFS=$as_save_IFS
10272   test -z "$as_dir" && as_dir=.
10273   for ac_exec_ext in '' $ac_executable_extensions; do
10274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10275     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10277     break 2
10278   fi
10279 done
10280 done
10281
10282 fi
10283 fi
10284 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10285 if test -n "$LD_FOR_TARGET"; then
10286   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10287 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10288 else
10289   echo "$as_me:$LINENO: result: no" >&5
10290 echo "${ECHO_T}no" >&6
10291 fi
10292
10293     fi
10294     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10295       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10296 set dummy ${ncn_progname}; ac_word=$2
10297 echo "$as_me:$LINENO: checking for $ac_word" >&5
10298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10299 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10300   echo $ECHO_N "(cached) $ECHO_C" >&6
10301 else
10302   if test -n "$LD_FOR_TARGET"; then
10303   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10304 else
10305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10306 for as_dir in $PATH
10307 do
10308   IFS=$as_save_IFS
10309   test -z "$as_dir" && as_dir=.
10310   for ac_exec_ext in '' $ac_executable_extensions; do
10311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10312     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10314     break 2
10315   fi
10316 done
10317 done
10318
10319 fi
10320 fi
10321 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10322 if test -n "$LD_FOR_TARGET"; then
10323   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10324 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10325 else
10326   echo "$as_me:$LINENO: result: no" >&5
10327 echo "${ECHO_T}no" >&6
10328 fi
10329
10330     fi
10331     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10332   done
10333 fi
10334
10335 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10336   set dummy ld
10337   if test $build = $target ; then
10338     LD_FOR_TARGET="$2"
10339   else
10340     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10341   fi
10342 else
10343   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10344 fi
10345
10346 else
10347   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10348 fi
10349
10350
10351
10352
10353 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10354   if test -n "$with_build_time_tools"; then
10355     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10356 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10357     if test -x $with_build_time_tools/lipo; then
10358       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10359       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10360       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10361 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10362     else
10363       echo "$as_me:$LINENO: result: no" >&5
10364 echo "${ECHO_T}no" >&6
10365     fi
10366   elif test $build != $host && test $have_gcc_for_target = yes; then
10367     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10368     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10369     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10370   fi
10371 fi
10372 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10373   # Extract the first word of "lipo", so it can be a program name with args.
10374 set dummy lipo; ac_word=$2
10375 echo "$as_me:$LINENO: checking for $ac_word" >&5
10376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10377 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10378   echo $ECHO_N "(cached) $ECHO_C" >&6
10379 else
10380   case $LIPO_FOR_TARGET in
10381   [\\/]* | ?:[\\/]*)
10382   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10383   ;;
10384   *)
10385   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10386 for as_dir in $gcc_cv_tool_dirs
10387 do
10388   IFS=$as_save_IFS
10389   test -z "$as_dir" && as_dir=.
10390   for ac_exec_ext in '' $ac_executable_extensions; do
10391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10392     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10394     break 2
10395   fi
10396 done
10397 done
10398
10399   ;;
10400 esac
10401 fi
10402 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10403
10404 if test -n "$LIPO_FOR_TARGET"; then
10405   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10406 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10407 else
10408   echo "$as_me:$LINENO: result: no" >&5
10409 echo "${ECHO_T}no" >&6
10410 fi
10411
10412 fi
10413 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10414
10415
10416 if test -n "$LIPO_FOR_TARGET"; then
10417   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10418 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10419   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10420 fi
10421
10422 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10423   for ncn_progname in lipo; do
10424     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10425 set dummy ${ncn_progname}; ac_word=$2
10426 echo "$as_me:$LINENO: checking for $ac_word" >&5
10427 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10428 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10429   echo $ECHO_N "(cached) $ECHO_C" >&6
10430 else
10431   if test -n "$LIPO_FOR_TARGET"; then
10432   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10433 else
10434 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10435 for as_dir in $PATH
10436 do
10437   IFS=$as_save_IFS
10438   test -z "$as_dir" && as_dir=.
10439   for ac_exec_ext in '' $ac_executable_extensions; do
10440   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10441     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10442     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10443     break 2
10444   fi
10445 done
10446 done
10447
10448 fi
10449 fi
10450 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10451 if test -n "$LIPO_FOR_TARGET"; then
10452   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10453 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10454 else
10455   echo "$as_me:$LINENO: result: no" >&5
10456 echo "${ECHO_T}no" >&6
10457 fi
10458
10459   done
10460 fi
10461
10462 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10463   for ncn_progname in lipo; do
10464     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10465 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10466     if test -x $with_build_time_tools/${ncn_progname}; then
10467       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10468       echo "$as_me:$LINENO: result: yes" >&5
10469 echo "${ECHO_T}yes" >&6
10470       break
10471     else
10472       echo "$as_me:$LINENO: result: no" >&5
10473 echo "${ECHO_T}no" >&6
10474     fi
10475   done
10476 fi
10477
10478 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10479   for ncn_progname in lipo; do
10480     if test -n "$ncn_target_tool_prefix"; then
10481       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10482 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10483 echo "$as_me:$LINENO: checking for $ac_word" >&5
10484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10485 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10486   echo $ECHO_N "(cached) $ECHO_C" >&6
10487 else
10488   if test -n "$LIPO_FOR_TARGET"; then
10489   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10490 else
10491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10492 for as_dir in $PATH
10493 do
10494   IFS=$as_save_IFS
10495   test -z "$as_dir" && as_dir=.
10496   for ac_exec_ext in '' $ac_executable_extensions; do
10497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10498     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10500     break 2
10501   fi
10502 done
10503 done
10504
10505 fi
10506 fi
10507 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10508 if test -n "$LIPO_FOR_TARGET"; then
10509   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10510 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10511 else
10512   echo "$as_me:$LINENO: result: no" >&5
10513 echo "${ECHO_T}no" >&6
10514 fi
10515
10516     fi
10517     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10518       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10519 set dummy ${ncn_progname}; ac_word=$2
10520 echo "$as_me:$LINENO: checking for $ac_word" >&5
10521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10522 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10523   echo $ECHO_N "(cached) $ECHO_C" >&6
10524 else
10525   if test -n "$LIPO_FOR_TARGET"; then
10526   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10527 else
10528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10529 for as_dir in $PATH
10530 do
10531   IFS=$as_save_IFS
10532   test -z "$as_dir" && as_dir=.
10533   for ac_exec_ext in '' $ac_executable_extensions; do
10534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10535     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10537     break 2
10538   fi
10539 done
10540 done
10541
10542 fi
10543 fi
10544 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10545 if test -n "$LIPO_FOR_TARGET"; then
10546   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10547 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10548 else
10549   echo "$as_me:$LINENO: result: no" >&5
10550 echo "${ECHO_T}no" >&6
10551 fi
10552
10553     fi
10554     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10555   done
10556 fi
10557
10558 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10559   set dummy lipo
10560   if test $build = $target ; then
10561     LIPO_FOR_TARGET="$2"
10562   else
10563     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10564   fi
10565 else
10566   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10567 fi
10568
10569 else
10570   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10571 fi
10572
10573
10574
10575
10576 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10577   if test -n "$with_build_time_tools"; then
10578     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10579 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10580     if test -x $with_build_time_tools/nm; then
10581       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10582       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10583       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10584 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10585     else
10586       echo "$as_me:$LINENO: result: no" >&5
10587 echo "${ECHO_T}no" >&6
10588     fi
10589   elif test $build != $host && test $have_gcc_for_target = yes; then
10590     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10591     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10592     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10593   fi
10594 fi
10595 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10596   # Extract the first word of "nm", so it can be a program name with args.
10597 set dummy nm; ac_word=$2
10598 echo "$as_me:$LINENO: checking for $ac_word" >&5
10599 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10600 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10601   echo $ECHO_N "(cached) $ECHO_C" >&6
10602 else
10603   case $NM_FOR_TARGET in
10604   [\\/]* | ?:[\\/]*)
10605   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10606   ;;
10607   *)
10608   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10609 for as_dir in $gcc_cv_tool_dirs
10610 do
10611   IFS=$as_save_IFS
10612   test -z "$as_dir" && as_dir=.
10613   for ac_exec_ext in '' $ac_executable_extensions; do
10614   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10615     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10616     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10617     break 2
10618   fi
10619 done
10620 done
10621
10622   ;;
10623 esac
10624 fi
10625 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10626
10627 if test -n "$NM_FOR_TARGET"; then
10628   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10629 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10630 else
10631   echo "$as_me:$LINENO: result: no" >&5
10632 echo "${ECHO_T}no" >&6
10633 fi
10634
10635 fi
10636 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10637
10638
10639 if test -n "$NM_FOR_TARGET"; then
10640   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10641 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10642   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10643 fi
10644
10645 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10646   for ncn_progname in nm; do
10647     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10648 set dummy ${ncn_progname}; ac_word=$2
10649 echo "$as_me:$LINENO: checking for $ac_word" >&5
10650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10651 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10652   echo $ECHO_N "(cached) $ECHO_C" >&6
10653 else
10654   if test -n "$NM_FOR_TARGET"; then
10655   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10656 else
10657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10658 for as_dir in $PATH
10659 do
10660   IFS=$as_save_IFS
10661   test -z "$as_dir" && as_dir=.
10662   for ac_exec_ext in '' $ac_executable_extensions; do
10663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10664     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10666     break 2
10667   fi
10668 done
10669 done
10670
10671 fi
10672 fi
10673 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10674 if test -n "$NM_FOR_TARGET"; then
10675   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10676 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10677 else
10678   echo "$as_me:$LINENO: result: no" >&5
10679 echo "${ECHO_T}no" >&6
10680 fi
10681
10682   done
10683 fi
10684
10685 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10686   for ncn_progname in nm; do
10687     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10688 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10689     if test -x $with_build_time_tools/${ncn_progname}; then
10690       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10691       echo "$as_me:$LINENO: result: yes" >&5
10692 echo "${ECHO_T}yes" >&6
10693       break
10694     else
10695       echo "$as_me:$LINENO: result: no" >&5
10696 echo "${ECHO_T}no" >&6
10697     fi
10698   done
10699 fi
10700
10701 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10702   for ncn_progname in nm; do
10703     if test -n "$ncn_target_tool_prefix"; then
10704       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10705 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10706 echo "$as_me:$LINENO: checking for $ac_word" >&5
10707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10708 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10709   echo $ECHO_N "(cached) $ECHO_C" >&6
10710 else
10711   if test -n "$NM_FOR_TARGET"; then
10712   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10713 else
10714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10715 for as_dir in $PATH
10716 do
10717   IFS=$as_save_IFS
10718   test -z "$as_dir" && as_dir=.
10719   for ac_exec_ext in '' $ac_executable_extensions; do
10720   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10721     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10722     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10723     break 2
10724   fi
10725 done
10726 done
10727
10728 fi
10729 fi
10730 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10731 if test -n "$NM_FOR_TARGET"; then
10732   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10733 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10734 else
10735   echo "$as_me:$LINENO: result: no" >&5
10736 echo "${ECHO_T}no" >&6
10737 fi
10738
10739     fi
10740     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10741       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10742 set dummy ${ncn_progname}; ac_word=$2
10743 echo "$as_me:$LINENO: checking for $ac_word" >&5
10744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10745 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10746   echo $ECHO_N "(cached) $ECHO_C" >&6
10747 else
10748   if test -n "$NM_FOR_TARGET"; then
10749   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10750 else
10751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10752 for as_dir in $PATH
10753 do
10754   IFS=$as_save_IFS
10755   test -z "$as_dir" && as_dir=.
10756   for ac_exec_ext in '' $ac_executable_extensions; do
10757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10758     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10760     break 2
10761   fi
10762 done
10763 done
10764
10765 fi
10766 fi
10767 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10768 if test -n "$NM_FOR_TARGET"; then
10769   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10770 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10771 else
10772   echo "$as_me:$LINENO: result: no" >&5
10773 echo "${ECHO_T}no" >&6
10774 fi
10775
10776     fi
10777     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10778   done
10779 fi
10780
10781 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10782   set dummy nm
10783   if test $build = $target ; then
10784     NM_FOR_TARGET="$2"
10785   else
10786     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10787   fi
10788 else
10789   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10790 fi
10791
10792 else
10793   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10794 fi
10795
10796
10797
10798
10799 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10800   if test -n "$with_build_time_tools"; then
10801     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10802 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10803     if test -x $with_build_time_tools/objdump; then
10804       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10805       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10806       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10807 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10808     else
10809       echo "$as_me:$LINENO: result: no" >&5
10810 echo "${ECHO_T}no" >&6
10811     fi
10812   elif test $build != $host && test $have_gcc_for_target = yes; then
10813     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10814     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10815     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10816   fi
10817 fi
10818 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10819   # Extract the first word of "objdump", so it can be a program name with args.
10820 set dummy objdump; ac_word=$2
10821 echo "$as_me:$LINENO: checking for $ac_word" >&5
10822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10823 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10824   echo $ECHO_N "(cached) $ECHO_C" >&6
10825 else
10826   case $OBJDUMP_FOR_TARGET in
10827   [\\/]* | ?:[\\/]*)
10828   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10829   ;;
10830   *)
10831   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10832 for as_dir in $gcc_cv_tool_dirs
10833 do
10834   IFS=$as_save_IFS
10835   test -z "$as_dir" && as_dir=.
10836   for ac_exec_ext in '' $ac_executable_extensions; do
10837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10838     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10840     break 2
10841   fi
10842 done
10843 done
10844
10845   ;;
10846 esac
10847 fi
10848 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10849
10850 if test -n "$OBJDUMP_FOR_TARGET"; then
10851   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10852 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10853 else
10854   echo "$as_me:$LINENO: result: no" >&5
10855 echo "${ECHO_T}no" >&6
10856 fi
10857
10858 fi
10859 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10860
10861
10862 if test -n "$OBJDUMP_FOR_TARGET"; then
10863   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10864 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10865   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10866 fi
10867
10868 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10869   for ncn_progname in objdump; do
10870     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10871 set dummy ${ncn_progname}; ac_word=$2
10872 echo "$as_me:$LINENO: checking for $ac_word" >&5
10873 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10874 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10875   echo $ECHO_N "(cached) $ECHO_C" >&6
10876 else
10877   if test -n "$OBJDUMP_FOR_TARGET"; then
10878   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10879 else
10880 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10881 for as_dir in $PATH
10882 do
10883   IFS=$as_save_IFS
10884   test -z "$as_dir" && as_dir=.
10885   for ac_exec_ext in '' $ac_executable_extensions; do
10886   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10887     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10888     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10889     break 2
10890   fi
10891 done
10892 done
10893
10894 fi
10895 fi
10896 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10897 if test -n "$OBJDUMP_FOR_TARGET"; then
10898   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10899 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10900 else
10901   echo "$as_me:$LINENO: result: no" >&5
10902 echo "${ECHO_T}no" >&6
10903 fi
10904
10905   done
10906 fi
10907
10908 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10909   for ncn_progname in objdump; do
10910     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10911 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10912     if test -x $with_build_time_tools/${ncn_progname}; then
10913       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10914       echo "$as_me:$LINENO: result: yes" >&5
10915 echo "${ECHO_T}yes" >&6
10916       break
10917     else
10918       echo "$as_me:$LINENO: result: no" >&5
10919 echo "${ECHO_T}no" >&6
10920     fi
10921   done
10922 fi
10923
10924 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10925   for ncn_progname in objdump; do
10926     if test -n "$ncn_target_tool_prefix"; then
10927       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10928 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10929 echo "$as_me:$LINENO: checking for $ac_word" >&5
10930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10931 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10932   echo $ECHO_N "(cached) $ECHO_C" >&6
10933 else
10934   if test -n "$OBJDUMP_FOR_TARGET"; then
10935   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10936 else
10937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10938 for as_dir in $PATH
10939 do
10940   IFS=$as_save_IFS
10941   test -z "$as_dir" && as_dir=.
10942   for ac_exec_ext in '' $ac_executable_extensions; do
10943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10944     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10946     break 2
10947   fi
10948 done
10949 done
10950
10951 fi
10952 fi
10953 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10954 if test -n "$OBJDUMP_FOR_TARGET"; then
10955   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10956 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10957 else
10958   echo "$as_me:$LINENO: result: no" >&5
10959 echo "${ECHO_T}no" >&6
10960 fi
10961
10962     fi
10963     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10964       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10965 set dummy ${ncn_progname}; ac_word=$2
10966 echo "$as_me:$LINENO: checking for $ac_word" >&5
10967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10968 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10969   echo $ECHO_N "(cached) $ECHO_C" >&6
10970 else
10971   if test -n "$OBJDUMP_FOR_TARGET"; then
10972   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10973 else
10974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10975 for as_dir in $PATH
10976 do
10977   IFS=$as_save_IFS
10978   test -z "$as_dir" && as_dir=.
10979   for ac_exec_ext in '' $ac_executable_extensions; do
10980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10981     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10983     break 2
10984   fi
10985 done
10986 done
10987
10988 fi
10989 fi
10990 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10991 if test -n "$OBJDUMP_FOR_TARGET"; then
10992   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10993 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10994 else
10995   echo "$as_me:$LINENO: result: no" >&5
10996 echo "${ECHO_T}no" >&6
10997 fi
10998
10999     fi
11000     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11001   done
11002 fi
11003
11004 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11005   set dummy objdump
11006   if test $build = $target ; then
11007     OBJDUMP_FOR_TARGET="$2"
11008   else
11009     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11010   fi
11011 else
11012   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11013 fi
11014
11015 else
11016   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11017 fi
11018
11019
11020
11021
11022 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11023   if test -n "$with_build_time_tools"; then
11024     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11025 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11026     if test -x $with_build_time_tools/ranlib; then
11027       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11028       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11029       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11030 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11031     else
11032       echo "$as_me:$LINENO: result: no" >&5
11033 echo "${ECHO_T}no" >&6
11034     fi
11035   elif test $build != $host && test $have_gcc_for_target = yes; then
11036     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11037     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11038     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11039   fi
11040 fi
11041 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11042   # Extract the first word of "ranlib", so it can be a program name with args.
11043 set dummy ranlib; ac_word=$2
11044 echo "$as_me:$LINENO: checking for $ac_word" >&5
11045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11046 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11047   echo $ECHO_N "(cached) $ECHO_C" >&6
11048 else
11049   case $RANLIB_FOR_TARGET in
11050   [\\/]* | ?:[\\/]*)
11051   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11052   ;;
11053   *)
11054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11055 for as_dir in $gcc_cv_tool_dirs
11056 do
11057   IFS=$as_save_IFS
11058   test -z "$as_dir" && as_dir=.
11059   for ac_exec_ext in '' $ac_executable_extensions; do
11060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11061     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11063     break 2
11064   fi
11065 done
11066 done
11067
11068   ;;
11069 esac
11070 fi
11071 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11072
11073 if test -n "$RANLIB_FOR_TARGET"; then
11074   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11075 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11076 else
11077   echo "$as_me:$LINENO: result: no" >&5
11078 echo "${ECHO_T}no" >&6
11079 fi
11080
11081 fi
11082 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11083
11084
11085 if test -n "$RANLIB_FOR_TARGET"; then
11086   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11087 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11088   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11089 fi
11090
11091 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11092   for ncn_progname in ranlib; do
11093     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11094 set dummy ${ncn_progname}; ac_word=$2
11095 echo "$as_me:$LINENO: checking for $ac_word" >&5
11096 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11097 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11098   echo $ECHO_N "(cached) $ECHO_C" >&6
11099 else
11100   if test -n "$RANLIB_FOR_TARGET"; then
11101   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11102 else
11103 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11104 for as_dir in $PATH
11105 do
11106   IFS=$as_save_IFS
11107   test -z "$as_dir" && as_dir=.
11108   for ac_exec_ext in '' $ac_executable_extensions; do
11109   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11110     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11111     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11112     break 2
11113   fi
11114 done
11115 done
11116
11117 fi
11118 fi
11119 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11120 if test -n "$RANLIB_FOR_TARGET"; then
11121   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11122 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11123 else
11124   echo "$as_me:$LINENO: result: no" >&5
11125 echo "${ECHO_T}no" >&6
11126 fi
11127
11128   done
11129 fi
11130
11131 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11132   for ncn_progname in ranlib; do
11133     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11134 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11135     if test -x $with_build_time_tools/${ncn_progname}; then
11136       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11137       echo "$as_me:$LINENO: result: yes" >&5
11138 echo "${ECHO_T}yes" >&6
11139       break
11140     else
11141       echo "$as_me:$LINENO: result: no" >&5
11142 echo "${ECHO_T}no" >&6
11143     fi
11144   done
11145 fi
11146
11147 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11148   for ncn_progname in ranlib; do
11149     if test -n "$ncn_target_tool_prefix"; then
11150       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11151 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11152 echo "$as_me:$LINENO: checking for $ac_word" >&5
11153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11154 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11155   echo $ECHO_N "(cached) $ECHO_C" >&6
11156 else
11157   if test -n "$RANLIB_FOR_TARGET"; then
11158   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11159 else
11160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11161 for as_dir in $PATH
11162 do
11163   IFS=$as_save_IFS
11164   test -z "$as_dir" && as_dir=.
11165   for ac_exec_ext in '' $ac_executable_extensions; do
11166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11167     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11169     break 2
11170   fi
11171 done
11172 done
11173
11174 fi
11175 fi
11176 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11177 if test -n "$RANLIB_FOR_TARGET"; then
11178   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11179 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11180 else
11181   echo "$as_me:$LINENO: result: no" >&5
11182 echo "${ECHO_T}no" >&6
11183 fi
11184
11185     fi
11186     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11187       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11188 set dummy ${ncn_progname}; ac_word=$2
11189 echo "$as_me:$LINENO: checking for $ac_word" >&5
11190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11191 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11192   echo $ECHO_N "(cached) $ECHO_C" >&6
11193 else
11194   if test -n "$RANLIB_FOR_TARGET"; then
11195   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11196 else
11197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11198 for as_dir in $PATH
11199 do
11200   IFS=$as_save_IFS
11201   test -z "$as_dir" && as_dir=.
11202   for ac_exec_ext in '' $ac_executable_extensions; do
11203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11204     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11206     break 2
11207   fi
11208 done
11209 done
11210
11211 fi
11212 fi
11213 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11214 if test -n "$RANLIB_FOR_TARGET"; then
11215   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11216 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11217 else
11218   echo "$as_me:$LINENO: result: no" >&5
11219 echo "${ECHO_T}no" >&6
11220 fi
11221
11222     fi
11223     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11224   done
11225 fi
11226
11227 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11228   set dummy ranlib
11229   if test $build = $target ; then
11230     RANLIB_FOR_TARGET="$2"
11231   else
11232     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11233   fi
11234 else
11235   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11236 fi
11237
11238 else
11239   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11240 fi
11241
11242
11243
11244
11245 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11246   if test -n "$with_build_time_tools"; then
11247     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11248 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11249     if test -x $with_build_time_tools/strip; then
11250       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11251       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11252       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11253 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11254     else
11255       echo "$as_me:$LINENO: result: no" >&5
11256 echo "${ECHO_T}no" >&6
11257     fi
11258   elif test $build != $host && test $have_gcc_for_target = yes; then
11259     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11260     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11261     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11262   fi
11263 fi
11264 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11265   # Extract the first word of "strip", so it can be a program name with args.
11266 set dummy strip; ac_word=$2
11267 echo "$as_me:$LINENO: checking for $ac_word" >&5
11268 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11269 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11270   echo $ECHO_N "(cached) $ECHO_C" >&6
11271 else
11272   case $STRIP_FOR_TARGET in
11273   [\\/]* | ?:[\\/]*)
11274   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11275   ;;
11276   *)
11277   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11278 for as_dir in $gcc_cv_tool_dirs
11279 do
11280   IFS=$as_save_IFS
11281   test -z "$as_dir" && as_dir=.
11282   for ac_exec_ext in '' $ac_executable_extensions; do
11283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11284     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11286     break 2
11287   fi
11288 done
11289 done
11290
11291   ;;
11292 esac
11293 fi
11294 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11295
11296 if test -n "$STRIP_FOR_TARGET"; then
11297   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11298 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11299 else
11300   echo "$as_me:$LINENO: result: no" >&5
11301 echo "${ECHO_T}no" >&6
11302 fi
11303
11304 fi
11305 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11306
11307
11308 if test -n "$STRIP_FOR_TARGET"; then
11309   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11310 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11311   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11312 fi
11313
11314 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11315   for ncn_progname in strip; do
11316     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11317 set dummy ${ncn_progname}; ac_word=$2
11318 echo "$as_me:$LINENO: checking for $ac_word" >&5
11319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11320 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11321   echo $ECHO_N "(cached) $ECHO_C" >&6
11322 else
11323   if test -n "$STRIP_FOR_TARGET"; then
11324   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11325 else
11326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11327 for as_dir in $PATH
11328 do
11329   IFS=$as_save_IFS
11330   test -z "$as_dir" && as_dir=.
11331   for ac_exec_ext in '' $ac_executable_extensions; do
11332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11333     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11335     break 2
11336   fi
11337 done
11338 done
11339
11340 fi
11341 fi
11342 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11343 if test -n "$STRIP_FOR_TARGET"; then
11344   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11345 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11346 else
11347   echo "$as_me:$LINENO: result: no" >&5
11348 echo "${ECHO_T}no" >&6
11349 fi
11350
11351   done
11352 fi
11353
11354 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11355   for ncn_progname in strip; do
11356     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11357 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11358     if test -x $with_build_time_tools/${ncn_progname}; then
11359       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11360       echo "$as_me:$LINENO: result: yes" >&5
11361 echo "${ECHO_T}yes" >&6
11362       break
11363     else
11364       echo "$as_me:$LINENO: result: no" >&5
11365 echo "${ECHO_T}no" >&6
11366     fi
11367   done
11368 fi
11369
11370 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11371   for ncn_progname in strip; do
11372     if test -n "$ncn_target_tool_prefix"; then
11373       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11374 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11375 echo "$as_me:$LINENO: checking for $ac_word" >&5
11376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11377 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11378   echo $ECHO_N "(cached) $ECHO_C" >&6
11379 else
11380   if test -n "$STRIP_FOR_TARGET"; then
11381   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11382 else
11383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11384 for as_dir in $PATH
11385 do
11386   IFS=$as_save_IFS
11387   test -z "$as_dir" && as_dir=.
11388   for ac_exec_ext in '' $ac_executable_extensions; do
11389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11390     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11392     break 2
11393   fi
11394 done
11395 done
11396
11397 fi
11398 fi
11399 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11400 if test -n "$STRIP_FOR_TARGET"; then
11401   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11402 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11403 else
11404   echo "$as_me:$LINENO: result: no" >&5
11405 echo "${ECHO_T}no" >&6
11406 fi
11407
11408     fi
11409     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11410       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11411 set dummy ${ncn_progname}; ac_word=$2
11412 echo "$as_me:$LINENO: checking for $ac_word" >&5
11413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11414 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11415   echo $ECHO_N "(cached) $ECHO_C" >&6
11416 else
11417   if test -n "$STRIP_FOR_TARGET"; then
11418   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11419 else
11420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11421 for as_dir in $PATH
11422 do
11423   IFS=$as_save_IFS
11424   test -z "$as_dir" && as_dir=.
11425   for ac_exec_ext in '' $ac_executable_extensions; do
11426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11427     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11429     break 2
11430   fi
11431 done
11432 done
11433
11434 fi
11435 fi
11436 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11437 if test -n "$STRIP_FOR_TARGET"; then
11438   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11439 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11440 else
11441   echo "$as_me:$LINENO: result: no" >&5
11442 echo "${ECHO_T}no" >&6
11443 fi
11444
11445     fi
11446     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11447   done
11448 fi
11449
11450 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11451   set dummy strip
11452   if test $build = $target ; then
11453     STRIP_FOR_TARGET="$2"
11454   else
11455     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11456   fi
11457 else
11458   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11459 fi
11460
11461 else
11462   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11463 fi
11464
11465
11466
11467
11468 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11469   if test -n "$with_build_time_tools"; then
11470     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11471 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11472     if test -x $with_build_time_tools/windres; then
11473       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11474       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11475       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11476 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11477     else
11478       echo "$as_me:$LINENO: result: no" >&5
11479 echo "${ECHO_T}no" >&6
11480     fi
11481   elif test $build != $host && test $have_gcc_for_target = yes; then
11482     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11483     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11484     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11485   fi
11486 fi
11487 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11488   # Extract the first word of "windres", so it can be a program name with args.
11489 set dummy windres; ac_word=$2
11490 echo "$as_me:$LINENO: checking for $ac_word" >&5
11491 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11492 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11493   echo $ECHO_N "(cached) $ECHO_C" >&6
11494 else
11495   case $WINDRES_FOR_TARGET in
11496   [\\/]* | ?:[\\/]*)
11497   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11498   ;;
11499   *)
11500   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11501 for as_dir in $gcc_cv_tool_dirs
11502 do
11503   IFS=$as_save_IFS
11504   test -z "$as_dir" && as_dir=.
11505   for ac_exec_ext in '' $ac_executable_extensions; do
11506   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11507     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11508     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11509     break 2
11510   fi
11511 done
11512 done
11513
11514   ;;
11515 esac
11516 fi
11517 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11518
11519 if test -n "$WINDRES_FOR_TARGET"; then
11520   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11521 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11522 else
11523   echo "$as_me:$LINENO: result: no" >&5
11524 echo "${ECHO_T}no" >&6
11525 fi
11526
11527 fi
11528 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11529
11530
11531 if test -n "$WINDRES_FOR_TARGET"; then
11532   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11533 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11534   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11535 fi
11536
11537 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11538   for ncn_progname in windres; do
11539     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11540 set dummy ${ncn_progname}; ac_word=$2
11541 echo "$as_me:$LINENO: checking for $ac_word" >&5
11542 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11543 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11544   echo $ECHO_N "(cached) $ECHO_C" >&6
11545 else
11546   if test -n "$WINDRES_FOR_TARGET"; then
11547   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11548 else
11549 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11550 for as_dir in $PATH
11551 do
11552   IFS=$as_save_IFS
11553   test -z "$as_dir" && as_dir=.
11554   for ac_exec_ext in '' $ac_executable_extensions; do
11555   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11556     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11557     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11558     break 2
11559   fi
11560 done
11561 done
11562
11563 fi
11564 fi
11565 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11566 if test -n "$WINDRES_FOR_TARGET"; then
11567   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11568 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11569 else
11570   echo "$as_me:$LINENO: result: no" >&5
11571 echo "${ECHO_T}no" >&6
11572 fi
11573
11574   done
11575 fi
11576
11577 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11578   for ncn_progname in windres; do
11579     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11580 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11581     if test -x $with_build_time_tools/${ncn_progname}; then
11582       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11583       echo "$as_me:$LINENO: result: yes" >&5
11584 echo "${ECHO_T}yes" >&6
11585       break
11586     else
11587       echo "$as_me:$LINENO: result: no" >&5
11588 echo "${ECHO_T}no" >&6
11589     fi
11590   done
11591 fi
11592
11593 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11594   for ncn_progname in windres; do
11595     if test -n "$ncn_target_tool_prefix"; then
11596       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11597 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11598 echo "$as_me:$LINENO: checking for $ac_word" >&5
11599 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11600 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11601   echo $ECHO_N "(cached) $ECHO_C" >&6
11602 else
11603   if test -n "$WINDRES_FOR_TARGET"; then
11604   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11605 else
11606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11607 for as_dir in $PATH
11608 do
11609   IFS=$as_save_IFS
11610   test -z "$as_dir" && as_dir=.
11611   for ac_exec_ext in '' $ac_executable_extensions; do
11612   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11613     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11614     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11615     break 2
11616   fi
11617 done
11618 done
11619
11620 fi
11621 fi
11622 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11623 if test -n "$WINDRES_FOR_TARGET"; then
11624   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11625 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11626 else
11627   echo "$as_me:$LINENO: result: no" >&5
11628 echo "${ECHO_T}no" >&6
11629 fi
11630
11631     fi
11632     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11633       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11634 set dummy ${ncn_progname}; ac_word=$2
11635 echo "$as_me:$LINENO: checking for $ac_word" >&5
11636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11637 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11638   echo $ECHO_N "(cached) $ECHO_C" >&6
11639 else
11640   if test -n "$WINDRES_FOR_TARGET"; then
11641   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11642 else
11643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11644 for as_dir in $PATH
11645 do
11646   IFS=$as_save_IFS
11647   test -z "$as_dir" && as_dir=.
11648   for ac_exec_ext in '' $ac_executable_extensions; do
11649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11650     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11652     break 2
11653   fi
11654 done
11655 done
11656
11657 fi
11658 fi
11659 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11660 if test -n "$WINDRES_FOR_TARGET"; then
11661   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11662 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11663 else
11664   echo "$as_me:$LINENO: result: no" >&5
11665 echo "${ECHO_T}no" >&6
11666 fi
11667
11668     fi
11669     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11670   done
11671 fi
11672
11673 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11674   set dummy windres
11675   if test $build = $target ; then
11676     WINDRES_FOR_TARGET="$2"
11677   else
11678     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11679   fi
11680 else
11681   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11682 fi
11683
11684 else
11685   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11686 fi
11687
11688
11689
11690
11691 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11692   if test -n "$with_build_time_tools"; then
11693     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11694 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11695     if test -x $with_build_time_tools/windmc; then
11696       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11697       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11698       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11699 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11700     else
11701       echo "$as_me:$LINENO: result: no" >&5
11702 echo "${ECHO_T}no" >&6
11703     fi
11704   elif test $build != $host && test $have_gcc_for_target = yes; then
11705     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11706     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11707     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11708   fi
11709 fi
11710 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11711   # Extract the first word of "windmc", so it can be a program name with args.
11712 set dummy windmc; ac_word=$2
11713 echo "$as_me:$LINENO: checking for $ac_word" >&5
11714 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11715 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11716   echo $ECHO_N "(cached) $ECHO_C" >&6
11717 else
11718   case $WINDMC_FOR_TARGET in
11719   [\\/]* | ?:[\\/]*)
11720   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11721   ;;
11722   *)
11723   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11724 for as_dir in $gcc_cv_tool_dirs
11725 do
11726   IFS=$as_save_IFS
11727   test -z "$as_dir" && as_dir=.
11728   for ac_exec_ext in '' $ac_executable_extensions; do
11729   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11730     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11731     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11732     break 2
11733   fi
11734 done
11735 done
11736
11737   ;;
11738 esac
11739 fi
11740 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11741
11742 if test -n "$WINDMC_FOR_TARGET"; then
11743   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11744 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11745 else
11746   echo "$as_me:$LINENO: result: no" >&5
11747 echo "${ECHO_T}no" >&6
11748 fi
11749
11750 fi
11751 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11752
11753
11754 if test -n "$WINDMC_FOR_TARGET"; then
11755   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11756 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11757   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11758 fi
11759
11760 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11761   for ncn_progname in windmc; do
11762     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11763 set dummy ${ncn_progname}; ac_word=$2
11764 echo "$as_me:$LINENO: checking for $ac_word" >&5
11765 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11766 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11767   echo $ECHO_N "(cached) $ECHO_C" >&6
11768 else
11769   if test -n "$WINDMC_FOR_TARGET"; then
11770   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11771 else
11772 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11773 for as_dir in $PATH
11774 do
11775   IFS=$as_save_IFS
11776   test -z "$as_dir" && as_dir=.
11777   for ac_exec_ext in '' $ac_executable_extensions; do
11778   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11779     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11780     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11781     break 2
11782   fi
11783 done
11784 done
11785
11786 fi
11787 fi
11788 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11789 if test -n "$WINDMC_FOR_TARGET"; then
11790   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11791 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11792 else
11793   echo "$as_me:$LINENO: result: no" >&5
11794 echo "${ECHO_T}no" >&6
11795 fi
11796
11797   done
11798 fi
11799
11800 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11801   for ncn_progname in windmc; do
11802     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11803 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11804     if test -x $with_build_time_tools/${ncn_progname}; then
11805       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11806       echo "$as_me:$LINENO: result: yes" >&5
11807 echo "${ECHO_T}yes" >&6
11808       break
11809     else
11810       echo "$as_me:$LINENO: result: no" >&5
11811 echo "${ECHO_T}no" >&6
11812     fi
11813   done
11814 fi
11815
11816 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11817   for ncn_progname in windmc; do
11818     if test -n "$ncn_target_tool_prefix"; then
11819       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11820 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11821 echo "$as_me:$LINENO: checking for $ac_word" >&5
11822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11823 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11824   echo $ECHO_N "(cached) $ECHO_C" >&6
11825 else
11826   if test -n "$WINDMC_FOR_TARGET"; then
11827   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11828 else
11829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11830 for as_dir in $PATH
11831 do
11832   IFS=$as_save_IFS
11833   test -z "$as_dir" && as_dir=.
11834   for ac_exec_ext in '' $ac_executable_extensions; do
11835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11836     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11838     break 2
11839   fi
11840 done
11841 done
11842
11843 fi
11844 fi
11845 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11846 if test -n "$WINDMC_FOR_TARGET"; then
11847   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11848 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11849 else
11850   echo "$as_me:$LINENO: result: no" >&5
11851 echo "${ECHO_T}no" >&6
11852 fi
11853
11854     fi
11855     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11856       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11857 set dummy ${ncn_progname}; ac_word=$2
11858 echo "$as_me:$LINENO: checking for $ac_word" >&5
11859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11860 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11861   echo $ECHO_N "(cached) $ECHO_C" >&6
11862 else
11863   if test -n "$WINDMC_FOR_TARGET"; then
11864   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11865 else
11866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11867 for as_dir in $PATH
11868 do
11869   IFS=$as_save_IFS
11870   test -z "$as_dir" && as_dir=.
11871   for ac_exec_ext in '' $ac_executable_extensions; do
11872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11873     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11875     break 2
11876   fi
11877 done
11878 done
11879
11880 fi
11881 fi
11882 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11883 if test -n "$WINDMC_FOR_TARGET"; then
11884   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11885 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11886 else
11887   echo "$as_me:$LINENO: result: no" >&5
11888 echo "${ECHO_T}no" >&6
11889 fi
11890
11891     fi
11892     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11893   done
11894 fi
11895
11896 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11897   set dummy windmc
11898   if test $build = $target ; then
11899     WINDMC_FOR_TARGET="$2"
11900   else
11901     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11902   fi
11903 else
11904   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11905 fi
11906
11907 else
11908   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11909 fi
11910
11911
11912 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11913
11914 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11915 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11916 if test "x${build}" != "x${host}" ; then
11917   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11918     # We already found the complete path
11919     ac_dir=`dirname $AR_FOR_TARGET`
11920     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11921 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11922   else
11923     # Canadian cross, just use what we found
11924     echo "$as_me:$LINENO: result: pre-installed" >&5
11925 echo "${ECHO_T}pre-installed" >&6
11926   fi
11927 else
11928   ok=yes
11929   case " ${configdirs} " in
11930     *" binutils "*) ;;
11931     *) ok=no ;;
11932   esac
11933
11934   if test $ok = yes; then
11935     # An in-tree tool is available and we can use it
11936     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11937     echo "$as_me:$LINENO: result: just compiled" >&5
11938 echo "${ECHO_T}just compiled" >&6
11939   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11940     # We already found the complete path
11941     ac_dir=`dirname $AR_FOR_TARGET`
11942     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11943 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11944   elif test "x$target" = "x$host"; then
11945     # We can use an host tool
11946     AR_FOR_TARGET='$(AR)'
11947     echo "$as_me:$LINENO: result: host tool" >&5
11948 echo "${ECHO_T}host tool" >&6
11949   else
11950     # We need a cross tool
11951     echo "$as_me:$LINENO: result: pre-installed" >&5
11952 echo "${ECHO_T}pre-installed" >&6
11953   fi
11954 fi
11955
11956 echo "$as_me:$LINENO: checking where to find the target as" >&5
11957 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11958 if test "x${build}" != "x${host}" ; then
11959   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11960     # We already found the complete path
11961     ac_dir=`dirname $AS_FOR_TARGET`
11962     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11963 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11964   else
11965     # Canadian cross, just use what we found
11966     echo "$as_me:$LINENO: result: pre-installed" >&5
11967 echo "${ECHO_T}pre-installed" >&6
11968   fi
11969 else
11970   ok=yes
11971   case " ${configdirs} " in
11972     *" gas "*) ;;
11973     *) ok=no ;;
11974   esac
11975
11976   if test $ok = yes; then
11977     # An in-tree tool is available and we can use it
11978     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11979     echo "$as_me:$LINENO: result: just compiled" >&5
11980 echo "${ECHO_T}just compiled" >&6
11981   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11982     # We already found the complete path
11983     ac_dir=`dirname $AS_FOR_TARGET`
11984     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11985 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11986   elif test "x$target" = "x$host"; then
11987     # We can use an host tool
11988     AS_FOR_TARGET='$(AS)'
11989     echo "$as_me:$LINENO: result: host tool" >&5
11990 echo "${ECHO_T}host tool" >&6
11991   else
11992     # We need a cross tool
11993     echo "$as_me:$LINENO: result: pre-installed" >&5
11994 echo "${ECHO_T}pre-installed" >&6
11995   fi
11996 fi
11997
11998 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11999 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12000 if test "x${build}" != "x${host}" ; then
12001   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12002     # We already found the complete path
12003     ac_dir=`dirname $CC_FOR_TARGET`
12004     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12005 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12006   else
12007     # Canadian cross, just use what we found
12008     echo "$as_me:$LINENO: result: pre-installed" >&5
12009 echo "${ECHO_T}pre-installed" >&6
12010   fi
12011 else
12012   ok=yes
12013   case " ${configdirs} " in
12014     *" gcc "*) ;;
12015     *) ok=no ;;
12016   esac
12017
12018   if test $ok = yes; then
12019     # An in-tree tool is available and we can use it
12020     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12021     echo "$as_me:$LINENO: result: just compiled" >&5
12022 echo "${ECHO_T}just compiled" >&6
12023   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12024     # We already found the complete path
12025     ac_dir=`dirname $CC_FOR_TARGET`
12026     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12027 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12028   elif test "x$target" = "x$host"; then
12029     # We can use an host tool
12030     CC_FOR_TARGET='$(CC)'
12031     echo "$as_me:$LINENO: result: host tool" >&5
12032 echo "${ECHO_T}host tool" >&6
12033   else
12034     # We need a cross tool
12035     echo "$as_me:$LINENO: result: pre-installed" >&5
12036 echo "${ECHO_T}pre-installed" >&6
12037   fi
12038 fi
12039
12040 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12041 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12042 if test "x${build}" != "x${host}" ; then
12043   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12044     # We already found the complete path
12045     ac_dir=`dirname $CXX_FOR_TARGET`
12046     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12047 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12048   else
12049     # Canadian cross, just use what we found
12050     echo "$as_me:$LINENO: result: pre-installed" >&5
12051 echo "${ECHO_T}pre-installed" >&6
12052   fi
12053 else
12054   ok=yes
12055   case " ${configdirs} " in
12056     *" gcc "*) ;;
12057     *) ok=no ;;
12058   esac
12059   case ,${enable_languages}, in
12060     *,c++,*) ;;
12061     *) ok=no ;;
12062   esac
12063   if test $ok = yes; then
12064     # An in-tree tool is available and we can use it
12065     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'
12066     echo "$as_me:$LINENO: result: just compiled" >&5
12067 echo "${ECHO_T}just compiled" >&6
12068   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12069     # We already found the complete path
12070     ac_dir=`dirname $CXX_FOR_TARGET`
12071     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12072 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12073   elif test "x$target" = "x$host"; then
12074     # We can use an host tool
12075     CXX_FOR_TARGET='$(CXX)'
12076     echo "$as_me:$LINENO: result: host tool" >&5
12077 echo "${ECHO_T}host tool" >&6
12078   else
12079     # We need a cross tool
12080     echo "$as_me:$LINENO: result: pre-installed" >&5
12081 echo "${ECHO_T}pre-installed" >&6
12082   fi
12083 fi
12084
12085 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12086 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12087 if test "x${build}" != "x${host}" ; then
12088   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12089     # We already found the complete path
12090     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12091     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12092 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12093   else
12094     # Canadian cross, just use what we found
12095     echo "$as_me:$LINENO: result: pre-installed" >&5
12096 echo "${ECHO_T}pre-installed" >&6
12097   fi
12098 else
12099   ok=yes
12100   case " ${configdirs} " in
12101     *" gcc "*) ;;
12102     *) ok=no ;;
12103   esac
12104   case ,${enable_languages}, in
12105     *,c++,*) ;;
12106     *) ok=no ;;
12107   esac
12108   if test $ok = yes; then
12109     # An in-tree tool is available and we can use it
12110     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'
12111     echo "$as_me:$LINENO: result: just compiled" >&5
12112 echo "${ECHO_T}just compiled" >&6
12113   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12114     # We already found the complete path
12115     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12116     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12117 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12118   elif test "x$target" = "x$host"; then
12119     # We can use an host tool
12120     RAW_CXX_FOR_TARGET='$(CXX)'
12121     echo "$as_me:$LINENO: result: host tool" >&5
12122 echo "${ECHO_T}host tool" >&6
12123   else
12124     # We need a cross tool
12125     echo "$as_me:$LINENO: result: pre-installed" >&5
12126 echo "${ECHO_T}pre-installed" >&6
12127   fi
12128 fi
12129
12130 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12131 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12132 if test "x${build}" != "x${host}" ; then
12133   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12134     # We already found the complete path
12135     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12136     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12137 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12138   else
12139     # Canadian cross, just use what we found
12140     echo "$as_me:$LINENO: result: pre-installed" >&5
12141 echo "${ECHO_T}pre-installed" >&6
12142   fi
12143 else
12144   ok=yes
12145   case " ${configdirs} " in
12146     *" binutils "*) ;;
12147     *) ok=no ;;
12148   esac
12149
12150   if test $ok = yes; then
12151     # An in-tree tool is available and we can use it
12152     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12153     echo "$as_me:$LINENO: result: just compiled" >&5
12154 echo "${ECHO_T}just compiled" >&6
12155   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12156     # We already found the complete path
12157     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12158     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12159 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12160   elif test "x$target" = "x$host"; then
12161     # We can use an host tool
12162     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12163     echo "$as_me:$LINENO: result: host tool" >&5
12164 echo "${ECHO_T}host tool" >&6
12165   else
12166     # We need a cross tool
12167     echo "$as_me:$LINENO: result: pre-installed" >&5
12168 echo "${ECHO_T}pre-installed" >&6
12169   fi
12170 fi
12171
12172 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12173 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12174 if test "x${build}" != "x${host}" ; then
12175   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12176     # We already found the complete path
12177     ac_dir=`dirname $GCC_FOR_TARGET`
12178     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12179 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12180   else
12181     # Canadian cross, just use what we found
12182     echo "$as_me:$LINENO: result: pre-installed" >&5
12183 echo "${ECHO_T}pre-installed" >&6
12184   fi
12185 else
12186   ok=yes
12187   case " ${configdirs} " in
12188     *" gcc "*) ;;
12189     *) ok=no ;;
12190   esac
12191
12192   if test $ok = yes; then
12193     # An in-tree tool is available and we can use it
12194     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12195     echo "$as_me:$LINENO: result: just compiled" >&5
12196 echo "${ECHO_T}just compiled" >&6
12197   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12198     # We already found the complete path
12199     ac_dir=`dirname $GCC_FOR_TARGET`
12200     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12201 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12202   elif test "x$target" = "x$host"; then
12203     # We can use an host tool
12204     GCC_FOR_TARGET='$()'
12205     echo "$as_me:$LINENO: result: host tool" >&5
12206 echo "${ECHO_T}host tool" >&6
12207   else
12208     # We need a cross tool
12209     echo "$as_me:$LINENO: result: pre-installed" >&5
12210 echo "${ECHO_T}pre-installed" >&6
12211   fi
12212 fi
12213
12214 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12215 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12216 if test "x${build}" != "x${host}" ; then
12217   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12218     # We already found the complete path
12219     ac_dir=`dirname $GCJ_FOR_TARGET`
12220     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12221 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12222   else
12223     # Canadian cross, just use what we found
12224     echo "$as_me:$LINENO: result: pre-installed" >&5
12225 echo "${ECHO_T}pre-installed" >&6
12226   fi
12227 else
12228   ok=yes
12229   case " ${configdirs} " in
12230     *" gcc "*) ;;
12231     *) ok=no ;;
12232   esac
12233   case ,${enable_languages}, in
12234     *,java,*) ;;
12235     *) ok=no ;;
12236   esac
12237   if test $ok = yes; then
12238     # An in-tree tool is available and we can use it
12239     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12240     echo "$as_me:$LINENO: result: just compiled" >&5
12241 echo "${ECHO_T}just compiled" >&6
12242   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12243     # We already found the complete path
12244     ac_dir=`dirname $GCJ_FOR_TARGET`
12245     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12246 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12247   elif test "x$target" = "x$host"; then
12248     # We can use an host tool
12249     GCJ_FOR_TARGET='$(GCJ)'
12250     echo "$as_me:$LINENO: result: host tool" >&5
12251 echo "${ECHO_T}host tool" >&6
12252   else
12253     # We need a cross tool
12254     echo "$as_me:$LINENO: result: pre-installed" >&5
12255 echo "${ECHO_T}pre-installed" >&6
12256   fi
12257 fi
12258
12259 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12260 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12261 if test "x${build}" != "x${host}" ; then
12262   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12263     # We already found the complete path
12264     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12265     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12266 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12267   else
12268     # Canadian cross, just use what we found
12269     echo "$as_me:$LINENO: result: pre-installed" >&5
12270 echo "${ECHO_T}pre-installed" >&6
12271   fi
12272 else
12273   ok=yes
12274   case " ${configdirs} " in
12275     *" gcc "*) ;;
12276     *) ok=no ;;
12277   esac
12278   case ,${enable_languages}, in
12279     *,fortran,*) ;;
12280     *) ok=no ;;
12281   esac
12282   if test $ok = yes; then
12283     # An in-tree tool is available and we can use it
12284     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12285     echo "$as_me:$LINENO: result: just compiled" >&5
12286 echo "${ECHO_T}just compiled" >&6
12287   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12288     # We already found the complete path
12289     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12290     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12291 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12292   elif test "x$target" = "x$host"; then
12293     # We can use an host tool
12294     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12295     echo "$as_me:$LINENO: result: host tool" >&5
12296 echo "${ECHO_T}host tool" >&6
12297   else
12298     # We need a cross tool
12299     echo "$as_me:$LINENO: result: pre-installed" >&5
12300 echo "${ECHO_T}pre-installed" >&6
12301   fi
12302 fi
12303
12304 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12305 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12306 if test "x${build}" != "x${host}" ; then
12307   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12308     # We already found the complete path
12309     ac_dir=`dirname $LD_FOR_TARGET`
12310     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12311 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12312   else
12313     # Canadian cross, just use what we found
12314     echo "$as_me:$LINENO: result: pre-installed" >&5
12315 echo "${ECHO_T}pre-installed" >&6
12316   fi
12317 else
12318   ok=yes
12319   case " ${configdirs} " in
12320     *" ld "*) ;;
12321     *) ok=no ;;
12322   esac
12323
12324   if test $ok = yes; then
12325     # An in-tree tool is available and we can use it
12326     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12327     echo "$as_me:$LINENO: result: just compiled" >&5
12328 echo "${ECHO_T}just compiled" >&6
12329   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12330     # We already found the complete path
12331     ac_dir=`dirname $LD_FOR_TARGET`
12332     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12333 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12334   elif test "x$target" = "x$host"; then
12335     # We can use an host tool
12336     LD_FOR_TARGET='$(LD)'
12337     echo "$as_me:$LINENO: result: host tool" >&5
12338 echo "${ECHO_T}host tool" >&6
12339   else
12340     # We need a cross tool
12341     echo "$as_me:$LINENO: result: pre-installed" >&5
12342 echo "${ECHO_T}pre-installed" >&6
12343   fi
12344 fi
12345
12346 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12347 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12348 if test "x${build}" != "x${host}" ; then
12349   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12350     # We already found the complete path
12351     ac_dir=`dirname $LIPO_FOR_TARGET`
12352     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12353 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12354   else
12355     # Canadian cross, just use what we found
12356     echo "$as_me:$LINENO: result: pre-installed" >&5
12357 echo "${ECHO_T}pre-installed" >&6
12358   fi
12359 else
12360   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12361     # We already found the complete path
12362     ac_dir=`dirname $LIPO_FOR_TARGET`
12363     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12364 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12365   elif test "x$target" = "x$host"; then
12366     # We can use an host tool
12367     LIPO_FOR_TARGET='$(LIPO)'
12368     echo "$as_me:$LINENO: result: host tool" >&5
12369 echo "${ECHO_T}host tool" >&6
12370   else
12371     # We need a cross tool
12372     echo "$as_me:$LINENO: result: pre-installed" >&5
12373 echo "${ECHO_T}pre-installed" >&6
12374   fi
12375 fi
12376
12377 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12378 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12379 if test "x${build}" != "x${host}" ; then
12380   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12381     # We already found the complete path
12382     ac_dir=`dirname $NM_FOR_TARGET`
12383     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12384 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12385   else
12386     # Canadian cross, just use what we found
12387     echo "$as_me:$LINENO: result: pre-installed" >&5
12388 echo "${ECHO_T}pre-installed" >&6
12389   fi
12390 else
12391   ok=yes
12392   case " ${configdirs} " in
12393     *" binutils "*) ;;
12394     *) ok=no ;;
12395   esac
12396
12397   if test $ok = yes; then
12398     # An in-tree tool is available and we can use it
12399     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12400     echo "$as_me:$LINENO: result: just compiled" >&5
12401 echo "${ECHO_T}just compiled" >&6
12402   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12403     # We already found the complete path
12404     ac_dir=`dirname $NM_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   elif test "x$target" = "x$host"; then
12408     # We can use an host tool
12409     NM_FOR_TARGET='$(NM)'
12410     echo "$as_me:$LINENO: result: host tool" >&5
12411 echo "${ECHO_T}host tool" >&6
12412   else
12413     # We need a cross tool
12414     echo "$as_me:$LINENO: result: pre-installed" >&5
12415 echo "${ECHO_T}pre-installed" >&6
12416   fi
12417 fi
12418
12419 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12420 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12421 if test "x${build}" != "x${host}" ; then
12422   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12423     # We already found the complete path
12424     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12425     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12426 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12427   else
12428     # Canadian cross, just use what we found
12429     echo "$as_me:$LINENO: result: pre-installed" >&5
12430 echo "${ECHO_T}pre-installed" >&6
12431   fi
12432 else
12433   ok=yes
12434   case " ${configdirs} " in
12435     *" binutils "*) ;;
12436     *) ok=no ;;
12437   esac
12438
12439   if test $ok = yes; then
12440     # An in-tree tool is available and we can use it
12441     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12442     echo "$as_me:$LINENO: result: just compiled" >&5
12443 echo "${ECHO_T}just compiled" >&6
12444   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12445     # We already found the complete path
12446     ac_dir=`dirname $OBJDUMP_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   elif test "x$target" = "x$host"; then
12450     # We can use an host tool
12451     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12452     echo "$as_me:$LINENO: result: host tool" >&5
12453 echo "${ECHO_T}host tool" >&6
12454   else
12455     # We need a cross tool
12456     echo "$as_me:$LINENO: result: pre-installed" >&5
12457 echo "${ECHO_T}pre-installed" >&6
12458   fi
12459 fi
12460
12461 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12462 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12463 if test "x${build}" != "x${host}" ; then
12464   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12465     # We already found the complete path
12466     ac_dir=`dirname $RANLIB_FOR_TARGET`
12467     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12468 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12469   else
12470     # Canadian cross, just use what we found
12471     echo "$as_me:$LINENO: result: pre-installed" >&5
12472 echo "${ECHO_T}pre-installed" >&6
12473   fi
12474 else
12475   ok=yes
12476   case " ${configdirs} " in
12477     *" binutils "*) ;;
12478     *) ok=no ;;
12479   esac
12480
12481   if test $ok = yes; then
12482     # An in-tree tool is available and we can use it
12483     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12484     echo "$as_me:$LINENO: result: just compiled" >&5
12485 echo "${ECHO_T}just compiled" >&6
12486   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12487     # We already found the complete path
12488     ac_dir=`dirname $RANLIB_FOR_TARGET`
12489     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12490 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12491   elif test "x$target" = "x$host"; then
12492     # We can use an host tool
12493     RANLIB_FOR_TARGET='$(RANLIB)'
12494     echo "$as_me:$LINENO: result: host tool" >&5
12495 echo "${ECHO_T}host tool" >&6
12496   else
12497     # We need a cross tool
12498     echo "$as_me:$LINENO: result: pre-installed" >&5
12499 echo "${ECHO_T}pre-installed" >&6
12500   fi
12501 fi
12502
12503 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12504 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12505 if test "x${build}" != "x${host}" ; then
12506   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12507     # We already found the complete path
12508     ac_dir=`dirname $STRIP_FOR_TARGET`
12509     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12510 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12511   else
12512     # Canadian cross, just use what we found
12513     echo "$as_me:$LINENO: result: pre-installed" >&5
12514 echo "${ECHO_T}pre-installed" >&6
12515   fi
12516 else
12517   ok=yes
12518   case " ${configdirs} " in
12519     *" binutils "*) ;;
12520     *) ok=no ;;
12521   esac
12522
12523   if test $ok = yes; then
12524     # An in-tree tool is available and we can use it
12525     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12526     echo "$as_me:$LINENO: result: just compiled" >&5
12527 echo "${ECHO_T}just compiled" >&6
12528   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12529     # We already found the complete path
12530     ac_dir=`dirname $STRIP_FOR_TARGET`
12531     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12532 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12533   elif test "x$target" = "x$host"; then
12534     # We can use an host tool
12535     STRIP_FOR_TARGET='$(STRIP)'
12536     echo "$as_me:$LINENO: result: host tool" >&5
12537 echo "${ECHO_T}host tool" >&6
12538   else
12539     # We need a cross tool
12540     echo "$as_me:$LINENO: result: pre-installed" >&5
12541 echo "${ECHO_T}pre-installed" >&6
12542   fi
12543 fi
12544
12545 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12546 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12547 if test "x${build}" != "x${host}" ; then
12548   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12549     # We already found the complete path
12550     ac_dir=`dirname $WINDRES_FOR_TARGET`
12551     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12552 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12553   else
12554     # Canadian cross, just use what we found
12555     echo "$as_me:$LINENO: result: pre-installed" >&5
12556 echo "${ECHO_T}pre-installed" >&6
12557   fi
12558 else
12559   ok=yes
12560   case " ${configdirs} " in
12561     *" binutils "*) ;;
12562     *) ok=no ;;
12563   esac
12564
12565   if test $ok = yes; then
12566     # An in-tree tool is available and we can use it
12567     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12568     echo "$as_me:$LINENO: result: just compiled" >&5
12569 echo "${ECHO_T}just compiled" >&6
12570   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12571     # We already found the complete path
12572     ac_dir=`dirname $WINDRES_FOR_TARGET`
12573     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12574 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12575   elif test "x$target" = "x$host"; then
12576     # We can use an host tool
12577     WINDRES_FOR_TARGET='$(WINDRES)'
12578     echo "$as_me:$LINENO: result: host tool" >&5
12579 echo "${ECHO_T}host tool" >&6
12580   else
12581     # We need a cross tool
12582     echo "$as_me:$LINENO: result: pre-installed" >&5
12583 echo "${ECHO_T}pre-installed" >&6
12584   fi
12585 fi
12586
12587 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12588 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12589 if test "x${build}" != "x${host}" ; then
12590   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12591     # We already found the complete path
12592     ac_dir=`dirname $WINDMC_FOR_TARGET`
12593     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12594 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12595   else
12596     # Canadian cross, just use what we found
12597     echo "$as_me:$LINENO: result: pre-installed" >&5
12598 echo "${ECHO_T}pre-installed" >&6
12599   fi
12600 else
12601   ok=yes
12602   case " ${configdirs} " in
12603     *" binutils "*) ;;
12604     *) ok=no ;;
12605   esac
12606
12607   if test $ok = yes; then
12608     # An in-tree tool is available and we can use it
12609     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12610     echo "$as_me:$LINENO: result: just compiled" >&5
12611 echo "${ECHO_T}just compiled" >&6
12612   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12613     # We already found the complete path
12614     ac_dir=`dirname $WINDMC_FOR_TARGET`
12615     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12616 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12617   elif test "x$target" = "x$host"; then
12618     # We can use an host tool
12619     WINDMC_FOR_TARGET='$(WINDMC)'
12620     echo "$as_me:$LINENO: result: host tool" >&5
12621 echo "${ECHO_T}host tool" >&6
12622   else
12623     # We need a cross tool
12624     echo "$as_me:$LINENO: result: pre-installed" >&5
12625 echo "${ECHO_T}pre-installed" >&6
12626   fi
12627 fi
12628
12629
12630
12631
12632
12633 # Certain tools may need extra flags.
12634 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12635 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12636 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12637
12638 # When building target libraries, except in a Canadian cross, we use
12639 # the same toolchain as the compiler we just built.
12640 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12641 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12642 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12643 if test $host = $build; then
12644   case " $configdirs " in
12645     *" gcc "*)
12646       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12647       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12648       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12649       ;;
12650   esac
12651 fi
12652
12653
12654
12655
12656
12657 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12658 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12659 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12660 if test "${enable_maintainer_mode+set}" = set; then
12661   enableval="$enable_maintainer_mode"
12662   USE_MAINTAINER_MODE=$enableval
12663 else
12664   USE_MAINTAINER_MODE=no
12665 fi;
12666 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12667 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12668
12669
12670 if test "$USE_MAINTAINER_MODE" = yes; then
12671   MAINTAINER_MODE_TRUE=
12672   MAINTAINER_MODE_FALSE='#'
12673 else
12674   MAINTAINER_MODE_TRUE='#'
12675   MAINTAINER_MODE_FALSE=
12676 fi
12677 MAINT=$MAINTAINER_MODE_TRUE
12678
12679 # ---------------------
12680 # GCC bootstrap support
12681 # ---------------------
12682
12683 # Stage specific cflags for build.
12684 stage1_cflags="-g"
12685 case $build in
12686   vax-*-*)
12687     case ${GCC} in
12688       yes) stage1_cflags="-g -Wa,-J" ;;
12689       *) stage1_cflags="-g -J" ;;
12690     esac ;;
12691 esac
12692
12693 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12694 if test "$GCC" = yes; then
12695   saved_CFLAGS="$CFLAGS"
12696
12697   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12698   CFLAGS="$CFLAGS -fkeep-inline-functions"
12699   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12700 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12701   cat >conftest.$ac_ext <<_ACEOF
12702 /* confdefs.h.  */
12703 _ACEOF
12704 cat confdefs.h >>conftest.$ac_ext
12705 cat >>conftest.$ac_ext <<_ACEOF
12706 /* end confdefs.h.  */
12707
12708 #if (__GNUC__ < 3) \
12709     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12710                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12711 #error http://gcc.gnu.org/PR29382
12712 #endif
12713
12714 int
12715 main ()
12716 {
12717
12718   ;
12719   return 0;
12720 }
12721 _ACEOF
12722 rm -f conftest.$ac_objext
12723 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12724   (eval $ac_compile) 2>conftest.er1
12725   ac_status=$?
12726   grep -v '^ *+' conftest.er1 >conftest.err
12727   rm -f conftest.er1
12728   cat conftest.err >&5
12729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12730   (exit $ac_status); } &&
12731          { ac_try='test -z "$ac_c_werror_flag"
12732                          || test ! -s conftest.err'
12733   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12734   (eval $ac_try) 2>&5
12735   ac_status=$?
12736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12737   (exit $ac_status); }; } &&
12738          { ac_try='test -s conftest.$ac_objext'
12739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12740   (eval $ac_try) 2>&5
12741   ac_status=$?
12742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12743   (exit $ac_status); }; }; then
12744   echo "$as_me:$LINENO: result: yes" >&5
12745 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12746 else
12747   echo "$as_me: failed program was:" >&5
12748 sed 's/^/| /' conftest.$ac_ext >&5
12749
12750 echo "$as_me:$LINENO: result: no" >&5
12751 echo "${ECHO_T}no" >&6
12752 fi
12753 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12754
12755   CFLAGS="$saved_CFLAGS"
12756 fi
12757
12758
12759
12760 # Enable --enable-checking in stage1 of the compiler.
12761 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12762 if test "${enable_stage1_checking+set}" = set; then
12763   enableval="$enable_stage1_checking"
12764   stage1_checking=--enable-checking=${enable_stage1_checking}
12765 else
12766   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12767   stage1_checking=--enable-checking=yes,types
12768 else
12769   stage1_checking=--enable-checking=$enable_checking,types
12770 fi
12771 fi;
12772
12773
12774 # Enable -Werror in bootstrap stage2 and later.
12775 # Check whether --enable-werror or --disable-werror was given.
12776 if test "${enable_werror+set}" = set; then
12777   enableval="$enable_werror"
12778
12779 else
12780   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12781   enable_werror=yes
12782 else
12783   enable_werror=no
12784 fi
12785 fi;
12786 case ${enable_werror} in
12787   yes) stage2_werror_flag="--enable-werror-always" ;;
12788   *) stage2_werror_flag="" ;;
12789 esac
12790
12791
12792 # Flags needed to enable html installing and building
12793
12794 # Check whether --with-datarootdir or --without-datarootdir was given.
12795 if test "${with_datarootdir+set}" = set; then
12796   withval="$with_datarootdir"
12797   datarootdir="\${prefix}/${withval}"
12798 else
12799   datarootdir="\${prefix}/share"
12800 fi;
12801
12802
12803 # Check whether --with-docdir or --without-docdir was given.
12804 if test "${with_docdir+set}" = set; then
12805   withval="$with_docdir"
12806   docdir="\${prefix}/${withval}"
12807 else
12808   docdir="\${datarootdir}/doc"
12809 fi;
12810
12811
12812 # Check whether --with-pdfdir or --without-pdfdir was given.
12813 if test "${with_pdfdir+set}" = set; then
12814   withval="$with_pdfdir"
12815   pdfdir="\${prefix}/${withval}"
12816 else
12817   pdfdir="\${docdir}"
12818 fi;
12819
12820
12821 # Check whether --with-htmldir or --without-htmldir was given.
12822 if test "${with_htmldir+set}" = set; then
12823   withval="$with_htmldir"
12824   htmldir="\${prefix}/${withval}"
12825 else
12826   htmldir="\${docdir}"
12827 fi;
12828
12829
12830
12831
12832
12833
12834           ac_config_files="$ac_config_files Makefile"
12835 cat >confcache <<\_ACEOF
12836 # This file is a shell script that caches the results of configure
12837 # tests run on this system so they can be shared between configure
12838 # scripts and configure runs, see configure's option --config-cache.
12839 # It is not useful on other systems.  If it contains results you don't
12840 # want to keep, you may remove or edit it.
12841 #
12842 # config.status only pays attention to the cache file if you give it
12843 # the --recheck option to rerun configure.
12844 #
12845 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12846 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12847 # following values.
12848
12849 _ACEOF
12850
12851 # The following way of writing the cache mishandles newlines in values,
12852 # but we know of no workaround that is simple, portable, and efficient.
12853 # So, don't put newlines in cache variables' values.
12854 # Ultrix sh set writes to stderr and can't be redirected directly,
12855 # and sets the high bit in the cache file unless we assign to the vars.
12856 {
12857   (set) 2>&1 |
12858     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12859     *ac_space=\ *)
12860       # `set' does not quote correctly, so add quotes (double-quote
12861       # substitution turns \\\\ into \\, and sed turns \\ into \).
12862       sed -n \
12863         "s/'/'\\\\''/g;
12864           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12865       ;;
12866     *)
12867       # `set' quotes correctly as required by POSIX, so do not add quotes.
12868       sed -n \
12869         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12870       ;;
12871     esac;
12872 } |
12873   sed '
12874      t clear
12875      : clear
12876      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12877      t end
12878      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12879      : end' >>confcache
12880 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12881   if test -w $cache_file; then
12882     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12883     cat confcache >$cache_file
12884   else
12885     echo "not updating unwritable cache $cache_file"
12886   fi
12887 fi
12888 rm -f confcache
12889
12890 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12891 # Let make expand exec_prefix.
12892 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12893
12894 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12895 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12896 # trailing colons and then remove the whole line if VPATH becomes empty
12897 # (actually we leave an empty line to preserve line numbers).
12898 if test "x$srcdir" = x.; then
12899   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12900 s/:*\$(srcdir):*/:/;
12901 s/:*\${srcdir}:*/:/;
12902 s/:*@srcdir@:*/:/;
12903 s/^\([^=]*=[     ]*\):*/\1/;
12904 s/:*$//;
12905 s/^[^=]*=[       ]*$//;
12906 }'
12907 fi
12908
12909 # Transform confdefs.h into DEFS.
12910 # Protect against shell expansion while executing Makefile rules.
12911 # Protect against Makefile macro expansion.
12912 #
12913 # If the first sed substitution is executed (which looks for macros that
12914 # take arguments), then we branch to the quote section.  Otherwise,
12915 # look for a macro that doesn't take arguments.
12916 cat >confdef2opt.sed <<\_ACEOF
12917 t clear
12918 : clear
12919 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12920 t quote
12921 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12922 t quote
12923 d
12924 : quote
12925 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12926 s,\[,\\&,g
12927 s,\],\\&,g
12928 s,\$,$$,g
12929 p
12930 _ACEOF
12931 # We use echo to avoid assuming a particular line-breaking character.
12932 # The extra dot is to prevent the shell from consuming trailing
12933 # line-breaks from the sub-command output.  A line-break within
12934 # single-quotes doesn't work because, if this script is created in a
12935 # platform that uses two characters for line-breaks (e.g., DOS), tr
12936 # would break.
12937 ac_LF_and_DOT=`echo; echo .`
12938 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12939 rm -f confdef2opt.sed
12940
12941
12942 ac_libobjs=
12943 ac_ltlibobjs=
12944 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12945   # 1. Remove the extension, and $U if already installed.
12946   ac_i=`echo "$ac_i" |
12947          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12948   # 2. Add them.
12949   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12950   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12951 done
12952 LIBOBJS=$ac_libobjs
12953
12954 LTLIBOBJS=$ac_ltlibobjs
12955
12956
12957
12958 : ${CONFIG_STATUS=./config.status}
12959 ac_clean_files_save=$ac_clean_files
12960 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12961 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12962 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12963 cat >$CONFIG_STATUS <<_ACEOF
12964 #! $SHELL
12965 # Generated by $as_me.
12966 # Run this file to recreate the current configuration.
12967 # Compiler output produced by configure, useful for debugging
12968 # configure, is in config.log if it exists.
12969
12970 debug=false
12971 ac_cs_recheck=false
12972 ac_cs_silent=false
12973 SHELL=\${CONFIG_SHELL-$SHELL}
12974 _ACEOF
12975
12976 cat >>$CONFIG_STATUS <<\_ACEOF
12977 ## --------------------- ##
12978 ## M4sh Initialization.  ##
12979 ## --------------------- ##
12980
12981 # Be Bourne compatible
12982 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12983   emulate sh
12984   NULLCMD=:
12985   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12986   # is contrary to our usage.  Disable this feature.
12987   alias -g '${1+"$@"}'='"$@"'
12988 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12989   set -o posix
12990 fi
12991 DUALCASE=1; export DUALCASE # for MKS sh
12992
12993 # Support unset when possible.
12994 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12995   as_unset=unset
12996 else
12997   as_unset=false
12998 fi
12999
13000
13001 # Work around bugs in pre-3.0 UWIN ksh.
13002 $as_unset ENV MAIL MAILPATH
13003 PS1='$ '
13004 PS2='> '
13005 PS4='+ '
13006
13007 # NLS nuisances.
13008 for as_var in \
13009   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13010   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13011   LC_TELEPHONE LC_TIME
13012 do
13013   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13014     eval $as_var=C; export $as_var
13015   else
13016     $as_unset $as_var
13017   fi
13018 done
13019
13020 # Required to use basename.
13021 if expr a : '\(a\)' >/dev/null 2>&1; then
13022   as_expr=expr
13023 else
13024   as_expr=false
13025 fi
13026
13027 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13028   as_basename=basename
13029 else
13030   as_basename=false
13031 fi
13032
13033
13034 # Name of the executable.
13035 as_me=`$as_basename "$0" ||
13036 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13037          X"$0" : 'X\(//\)$' \| \
13038          X"$0" : 'X\(/\)$' \| \
13039          .     : '\(.\)' 2>/dev/null ||
13040 echo X/"$0" |
13041     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13042           /^X\/\(\/\/\)$/{ s//\1/; q; }
13043           /^X\/\(\/\).*/{ s//\1/; q; }
13044           s/.*/./; q'`
13045
13046
13047 # PATH needs CR, and LINENO needs CR and PATH.
13048 # Avoid depending upon Character Ranges.
13049 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13050 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13051 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13052 as_cr_digits='0123456789'
13053 as_cr_alnum=$as_cr_Letters$as_cr_digits
13054
13055 # The user is always right.
13056 if test "${PATH_SEPARATOR+set}" != set; then
13057   echo "#! /bin/sh" >conf$$.sh
13058   echo  "exit 0"   >>conf$$.sh
13059   chmod +x conf$$.sh
13060   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13061     PATH_SEPARATOR=';'
13062   else
13063     PATH_SEPARATOR=:
13064   fi
13065   rm -f conf$$.sh
13066 fi
13067
13068
13069   as_lineno_1=$LINENO
13070   as_lineno_2=$LINENO
13071   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13072   test "x$as_lineno_1" != "x$as_lineno_2" &&
13073   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13074   # Find who we are.  Look in the path if we contain no path at all
13075   # relative or not.
13076   case $0 in
13077     *[\\/]* ) as_myself=$0 ;;
13078     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13079 for as_dir in $PATH
13080 do
13081   IFS=$as_save_IFS
13082   test -z "$as_dir" && as_dir=.
13083   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13084 done
13085
13086        ;;
13087   esac
13088   # We did not find ourselves, most probably we were run as `sh COMMAND'
13089   # in which case we are not to be found in the path.
13090   if test "x$as_myself" = x; then
13091     as_myself=$0
13092   fi
13093   if test ! -f "$as_myself"; then
13094     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13095 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13096    { (exit 1); exit 1; }; }
13097   fi
13098   case $CONFIG_SHELL in
13099   '')
13100     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13101 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13102 do
13103   IFS=$as_save_IFS
13104   test -z "$as_dir" && as_dir=.
13105   for as_base in sh bash ksh sh5; do
13106          case $as_dir in
13107          /*)
13108            if ("$as_dir/$as_base" -c '
13109   as_lineno_1=$LINENO
13110   as_lineno_2=$LINENO
13111   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13112   test "x$as_lineno_1" != "x$as_lineno_2" &&
13113   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13114              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13115              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13116              CONFIG_SHELL=$as_dir/$as_base
13117              export CONFIG_SHELL
13118              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13119            fi;;
13120          esac
13121        done
13122 done
13123 ;;
13124   esac
13125
13126   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13127   # uniformly replaced by the line number.  The first 'sed' inserts a
13128   # line-number line before each line; the second 'sed' does the real
13129   # work.  The second script uses 'N' to pair each line-number line
13130   # with the numbered line, and appends trailing '-' during
13131   # substitution so that $LINENO is not a special case at line end.
13132   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13133   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13134   sed '=' <$as_myself |
13135     sed '
13136       N
13137       s,$,-,
13138       : loop
13139       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13140       t loop
13141       s,-$,,
13142       s,^['$as_cr_digits']*\n,,
13143     ' >$as_me.lineno &&
13144   chmod +x $as_me.lineno ||
13145     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13146 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13147    { (exit 1); exit 1; }; }
13148
13149   # Don't try to exec as it changes $[0], causing all sort of problems
13150   # (the dirname of $[0] is not the place where we might find the
13151   # original and so on.  Autoconf is especially sensible to this).
13152   . ./$as_me.lineno
13153   # Exit status is that of the last command.
13154   exit
13155 }
13156
13157
13158 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13159   *c*,-n*) ECHO_N= ECHO_C='
13160 ' ECHO_T='      ' ;;
13161   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13162   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13163 esac
13164
13165 if expr a : '\(a\)' >/dev/null 2>&1; then
13166   as_expr=expr
13167 else
13168   as_expr=false
13169 fi
13170
13171 rm -f conf$$ conf$$.exe conf$$.file
13172 echo >conf$$.file
13173 if ln -s conf$$.file conf$$ 2>/dev/null; then
13174   # We could just check for DJGPP; but this test a) works b) is more generic
13175   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13176   if test -f conf$$.exe; then
13177     # Don't use ln at all; we don't have any links
13178     as_ln_s='cp -p'
13179   else
13180     as_ln_s='ln -s'
13181   fi
13182 elif ln conf$$.file conf$$ 2>/dev/null; then
13183   as_ln_s=ln
13184 else
13185   as_ln_s='cp -p'
13186 fi
13187 rm -f conf$$ conf$$.exe conf$$.file
13188
13189 if mkdir -p . 2>/dev/null; then
13190   as_mkdir_p=:
13191 else
13192   test -d ./-p && rmdir ./-p
13193   as_mkdir_p=false
13194 fi
13195
13196 as_executable_p="test -f"
13197
13198 # Sed expression to map a string onto a valid CPP name.
13199 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13200
13201 # Sed expression to map a string onto a valid variable name.
13202 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13203
13204
13205 # IFS
13206 # We need space, tab and new line, in precisely that order.
13207 as_nl='
13208 '
13209 IFS="   $as_nl"
13210
13211 # CDPATH.
13212 $as_unset CDPATH
13213
13214 exec 6>&1
13215
13216 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13217 # report actual input values of CONFIG_FILES etc. instead of their
13218 # values after options handling.  Logging --version etc. is OK.
13219 exec 5>>config.log
13220 {
13221   echo
13222   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13223 ## Running $as_me. ##
13224 _ASBOX
13225 } >&5
13226 cat >&5 <<_CSEOF
13227
13228 This file was extended by $as_me, which was
13229 generated by GNU Autoconf 2.59.  Invocation command line was
13230
13231   CONFIG_FILES    = $CONFIG_FILES
13232   CONFIG_HEADERS  = $CONFIG_HEADERS
13233   CONFIG_LINKS    = $CONFIG_LINKS
13234   CONFIG_COMMANDS = $CONFIG_COMMANDS
13235   $ $0 $@
13236
13237 _CSEOF
13238 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13239 echo >&5
13240 _ACEOF
13241
13242 # Files that config.status was made for.
13243 if test -n "$ac_config_files"; then
13244   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13245 fi
13246
13247 if test -n "$ac_config_headers"; then
13248   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13249 fi
13250
13251 if test -n "$ac_config_links"; then
13252   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13253 fi
13254
13255 if test -n "$ac_config_commands"; then
13256   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13257 fi
13258
13259 cat >>$CONFIG_STATUS <<\_ACEOF
13260
13261 ac_cs_usage="\
13262 \`$as_me' instantiates files from templates according to the
13263 current configuration.
13264
13265 Usage: $0 [OPTIONS] [FILE]...
13266
13267   -h, --help       print this help, then exit
13268   -V, --version    print version number, then exit
13269   -q, --quiet      do not print progress messages
13270   -d, --debug      don't remove temporary files
13271       --recheck    update $as_me by reconfiguring in the same conditions
13272   --file=FILE[:TEMPLATE]
13273                    instantiate the configuration file FILE
13274
13275 Configuration files:
13276 $config_files
13277
13278 Report bugs to <bug-autoconf@gnu.org>."
13279 _ACEOF
13280
13281 cat >>$CONFIG_STATUS <<_ACEOF
13282 ac_cs_version="\\
13283 config.status
13284 configured by $0, generated by GNU Autoconf 2.59,
13285   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13286
13287 Copyright (C) 2003 Free Software Foundation, Inc.
13288 This config.status script is free software; the Free Software Foundation
13289 gives unlimited permission to copy, distribute and modify it."
13290 srcdir=$srcdir
13291 INSTALL="$INSTALL"
13292 _ACEOF
13293
13294 cat >>$CONFIG_STATUS <<\_ACEOF
13295 # If no file are specified by the user, then we need to provide default
13296 # value.  By we need to know if files were specified by the user.
13297 ac_need_defaults=:
13298 while test $# != 0
13299 do
13300   case $1 in
13301   --*=*)
13302     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13303     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13304     ac_shift=:
13305     ;;
13306   -*)
13307     ac_option=$1
13308     ac_optarg=$2
13309     ac_shift=shift
13310     ;;
13311   *) # This is not an option, so the user has probably given explicit
13312      # arguments.
13313      ac_option=$1
13314      ac_need_defaults=false;;
13315   esac
13316
13317   case $ac_option in
13318   # Handling of the options.
13319 _ACEOF
13320 cat >>$CONFIG_STATUS <<\_ACEOF
13321   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13322     ac_cs_recheck=: ;;
13323   --version | --vers* | -V )
13324     echo "$ac_cs_version"; exit 0 ;;
13325   --he | --h)
13326     # Conflict between --help and --header
13327     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13328 Try \`$0 --help' for more information." >&5
13329 echo "$as_me: error: ambiguous option: $1
13330 Try \`$0 --help' for more information." >&2;}
13331    { (exit 1); exit 1; }; };;
13332   --help | --hel | -h )
13333     echo "$ac_cs_usage"; exit 0 ;;
13334   --debug | --d* | -d )
13335     debug=: ;;
13336   --file | --fil | --fi | --f )
13337     $ac_shift
13338     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13339     ac_need_defaults=false;;
13340   --header | --heade | --head | --hea )
13341     $ac_shift
13342     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13343     ac_need_defaults=false;;
13344   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13345   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13346     ac_cs_silent=: ;;
13347
13348   # This is an error.
13349   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13350 Try \`$0 --help' for more information." >&5
13351 echo "$as_me: error: unrecognized option: $1
13352 Try \`$0 --help' for more information." >&2;}
13353    { (exit 1); exit 1; }; } ;;
13354
13355   *) ac_config_targets="$ac_config_targets $1" ;;
13356
13357   esac
13358   shift
13359 done
13360
13361 ac_configure_extra_args=
13362
13363 if $ac_cs_silent; then
13364   exec 6>/dev/null
13365   ac_configure_extra_args="$ac_configure_extra_args --silent"
13366 fi
13367
13368 _ACEOF
13369 cat >>$CONFIG_STATUS <<_ACEOF
13370 if \$ac_cs_recheck; then
13371   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13372   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13373 fi
13374
13375 _ACEOF
13376
13377
13378
13379
13380
13381 cat >>$CONFIG_STATUS <<\_ACEOF
13382 for ac_config_target in $ac_config_targets
13383 do
13384   case "$ac_config_target" in
13385   # Handling of arguments.
13386   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13387   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13388 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13389    { (exit 1); exit 1; }; };;
13390   esac
13391 done
13392
13393 # If the user did not use the arguments to specify the items to instantiate,
13394 # then the envvar interface is used.  Set only those that are not.
13395 # We use the long form for the default assignment because of an extremely
13396 # bizarre bug on SunOS 4.1.3.
13397 if $ac_need_defaults; then
13398   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13399 fi
13400
13401 # Have a temporary directory for convenience.  Make it in the build tree
13402 # simply because there is no reason to put it here, and in addition,
13403 # creating and moving files from /tmp can sometimes cause problems.
13404 # Create a temporary directory, and hook for its removal unless debugging.
13405 $debug ||
13406 {
13407   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13408   trap '{ (exit 1); exit 1; }' 1 2 13 15
13409 }
13410
13411 # Create a (secure) tmp directory for tmp files.
13412
13413 {
13414   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13415   test -n "$tmp" && test -d "$tmp"
13416 }  ||
13417 {
13418   tmp=./confstat$$-$RANDOM
13419   (umask 077 && mkdir $tmp)
13420 } ||
13421 {
13422    echo "$me: cannot create a temporary directory in ." >&2
13423    { (exit 1); exit 1; }
13424 }
13425
13426 _ACEOF
13427
13428 cat >>$CONFIG_STATUS <<_ACEOF
13429
13430 #
13431 # CONFIG_FILES section.
13432 #
13433
13434 # No need to generate the scripts if there are no CONFIG_FILES.
13435 # This happens for instance when ./config.status config.h
13436 if test -n "\$CONFIG_FILES"; then
13437   # Protect against being on the right side of a sed subst in config.status.
13438   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13439    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13440 s,@SHELL@,$SHELL,;t t
13441 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13442 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13443 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13444 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13445 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13446 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13447 s,@exec_prefix@,$exec_prefix,;t t
13448 s,@prefix@,$prefix,;t t
13449 s,@program_transform_name@,$program_transform_name,;t t
13450 s,@bindir@,$bindir,;t t
13451 s,@sbindir@,$sbindir,;t t
13452 s,@libexecdir@,$libexecdir,;t t
13453 s,@datadir@,$datadir,;t t
13454 s,@sysconfdir@,$sysconfdir,;t t
13455 s,@sharedstatedir@,$sharedstatedir,;t t
13456 s,@localstatedir@,$localstatedir,;t t
13457 s,@libdir@,$libdir,;t t
13458 s,@includedir@,$includedir,;t t
13459 s,@oldincludedir@,$oldincludedir,;t t
13460 s,@infodir@,$infodir,;t t
13461 s,@mandir@,$mandir,;t t
13462 s,@build_alias@,$build_alias,;t t
13463 s,@host_alias@,$host_alias,;t t
13464 s,@target_alias@,$target_alias,;t t
13465 s,@DEFS@,$DEFS,;t t
13466 s,@ECHO_C@,$ECHO_C,;t t
13467 s,@ECHO_N@,$ECHO_N,;t t
13468 s,@ECHO_T@,$ECHO_T,;t t
13469 s,@LIBS@,$LIBS,;t t
13470 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13471 s,@build@,$build,;t t
13472 s,@build_cpu@,$build_cpu,;t t
13473 s,@build_vendor@,$build_vendor,;t t
13474 s,@build_os@,$build_os,;t t
13475 s,@build_noncanonical@,$build_noncanonical,;t t
13476 s,@host_noncanonical@,$host_noncanonical,;t t
13477 s,@target_noncanonical@,$target_noncanonical,;t t
13478 s,@host@,$host,;t t
13479 s,@host_cpu@,$host_cpu,;t t
13480 s,@host_vendor@,$host_vendor,;t t
13481 s,@host_os@,$host_os,;t t
13482 s,@target@,$target,;t t
13483 s,@target_cpu@,$target_cpu,;t t
13484 s,@target_vendor@,$target_vendor,;t t
13485 s,@target_os@,$target_os,;t t
13486 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13487 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13488 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13489 s,@LN@,$LN,;t t
13490 s,@LN_S@,$LN_S,;t t
13491 s,@build_libsubdir@,$build_libsubdir,;t t
13492 s,@build_subdir@,$build_subdir,;t t
13493 s,@host_subdir@,$host_subdir,;t t
13494 s,@target_subdir@,$target_subdir,;t t
13495 s,@CC@,$CC,;t t
13496 s,@CFLAGS@,$CFLAGS,;t t
13497 s,@LDFLAGS@,$LDFLAGS,;t t
13498 s,@CPPFLAGS@,$CPPFLAGS,;t t
13499 s,@ac_ct_CC@,$ac_ct_CC,;t t
13500 s,@EXEEXT@,$EXEEXT,;t t
13501 s,@OBJEXT@,$OBJEXT,;t t
13502 s,@CXX@,$CXX,;t t
13503 s,@CXXFLAGS@,$CXXFLAGS,;t t
13504 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13505 s,@GNATBIND@,$GNATBIND,;t t
13506 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13507 s,@GNATMAKE@,$GNATMAKE,;t t
13508 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13509 s,@do_compare@,$do_compare,;t t
13510 s,@gmplibs@,$gmplibs,;t t
13511 s,@gmpinc@,$gmpinc,;t t
13512 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13513 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13514 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13515 s,@ppllibs@,$ppllibs,;t t
13516 s,@pplinc@,$pplinc,;t t
13517 s,@clooglibs@,$clooglibs,;t t
13518 s,@clooginc@,$clooginc,;t t
13519 s,@stage1_languages@,$stage1_languages,;t t
13520 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13521 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13522 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13523 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13524 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13525 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13526 s,@tooldir@,$tooldir,;t t
13527 s,@build_tooldir@,$build_tooldir,;t t
13528 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13529 s,@GDB_TK@,$GDB_TK,;t t
13530 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13531 s,@build_configargs@,$build_configargs,;t t
13532 s,@build_configdirs@,$build_configdirs,;t t
13533 s,@host_configargs@,$host_configargs,;t t
13534 s,@configdirs@,$configdirs,;t t
13535 s,@target_configargs@,$target_configargs,;t t
13536 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13537 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13538 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13539 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13540 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13541 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13542 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13543 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13544 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13545 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13546 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13547 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13548 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13549 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13550 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13551 s,@config_shell@,$config_shell,;t t
13552 s,@YACC@,$YACC,;t t
13553 s,@BISON@,$BISON,;t t
13554 s,@M4@,$M4,;t t
13555 s,@LEX@,$LEX,;t t
13556 s,@FLEX@,$FLEX,;t t
13557 s,@MAKEINFO@,$MAKEINFO,;t t
13558 s,@EXPECT@,$EXPECT,;t t
13559 s,@RUNTEST@,$RUNTEST,;t t
13560 s,@AR@,$AR,;t t
13561 s,@AS@,$AS,;t t
13562 s,@DLLTOOL@,$DLLTOOL,;t t
13563 s,@LD@,$LD,;t t
13564 s,@LIPO@,$LIPO,;t t
13565 s,@NM@,$NM,;t t
13566 s,@RANLIB@,$RANLIB,;t t
13567 s,@STRIP@,$STRIP,;t t
13568 s,@WINDRES@,$WINDRES,;t t
13569 s,@WINDMC@,$WINDMC,;t t
13570 s,@OBJCOPY@,$OBJCOPY,;t t
13571 s,@OBJDUMP@,$OBJDUMP,;t t
13572 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13573 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13574 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13575 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13576 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13577 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13578 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13579 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13580 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13581 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13582 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13583 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13584 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13585 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13586 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13587 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13588 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13589 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13590 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13591 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13592 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13593 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13594 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13595 s,@MAINT@,$MAINT,;t t
13596 s,@stage1_cflags@,$stage1_cflags,;t t
13597 s,@stage1_checking@,$stage1_checking,;t t
13598 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13599 s,@datarootdir@,$datarootdir,;t t
13600 s,@docdir@,$docdir,;t t
13601 s,@pdfdir@,$pdfdir,;t t
13602 s,@htmldir@,$htmldir,;t t
13603 s,@LIBOBJS@,$LIBOBJS,;t t
13604 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13605 /@serialization_dependencies@/r $serialization_dependencies
13606 s,@serialization_dependencies@,,;t t
13607 /@host_makefile_frag@/r $host_makefile_frag
13608 s,@host_makefile_frag@,,;t t
13609 /@target_makefile_frag@/r $target_makefile_frag
13610 s,@target_makefile_frag@,,;t t
13611 /@alphaieee_frag@/r $alphaieee_frag
13612 s,@alphaieee_frag@,,;t t
13613 /@ospace_frag@/r $ospace_frag
13614 s,@ospace_frag@,,;t t
13615 CEOF
13616
13617 _ACEOF
13618
13619   cat >>$CONFIG_STATUS <<\_ACEOF
13620   # Split the substitutions into bite-sized pieces for seds with
13621   # small command number limits, like on Digital OSF/1 and HP-UX.
13622   ac_max_sed_lines=48
13623   ac_sed_frag=1 # Number of current file.
13624   ac_beg=1 # First line for current file.
13625   ac_end=$ac_max_sed_lines # Line after last line for current file.
13626   ac_more_lines=:
13627   ac_sed_cmds=
13628   while $ac_more_lines; do
13629     if test $ac_beg -gt 1; then
13630       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13631     else
13632       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13633     fi
13634     if test ! -s $tmp/subs.frag; then
13635       ac_more_lines=false
13636     else
13637       # The purpose of the label and of the branching condition is to
13638       # speed up the sed processing (if there are no `@' at all, there
13639       # is no need to browse any of the substitutions).
13640       # These are the two extra sed commands mentioned above.
13641       (echo ':t
13642   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13643       if test -z "$ac_sed_cmds"; then
13644         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13645       else
13646         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13647       fi
13648       ac_sed_frag=`expr $ac_sed_frag + 1`
13649       ac_beg=$ac_end
13650       ac_end=`expr $ac_end + $ac_max_sed_lines`
13651     fi
13652   done
13653   if test -z "$ac_sed_cmds"; then
13654     ac_sed_cmds=cat
13655   fi
13656 fi # test -n "$CONFIG_FILES"
13657
13658 _ACEOF
13659 cat >>$CONFIG_STATUS <<\_ACEOF
13660 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13661   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13662   case $ac_file in
13663   - | *:- | *:-:* ) # input from stdin
13664         cat >$tmp/stdin
13665         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13666         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13667   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13668         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13669   * )   ac_file_in=$ac_file.in ;;
13670   esac
13671
13672   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13673   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13674 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13675          X"$ac_file" : 'X\(//\)[^/]' \| \
13676          X"$ac_file" : 'X\(//\)$' \| \
13677          X"$ac_file" : 'X\(/\)' \| \
13678          .     : '\(.\)' 2>/dev/null ||
13679 echo X"$ac_file" |
13680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13682           /^X\(\/\/\)$/{ s//\1/; q; }
13683           /^X\(\/\).*/{ s//\1/; q; }
13684           s/.*/./; q'`
13685   { if $as_mkdir_p; then
13686     mkdir -p "$ac_dir"
13687   else
13688     as_dir="$ac_dir"
13689     as_dirs=
13690     while test ! -d "$as_dir"; do
13691       as_dirs="$as_dir $as_dirs"
13692       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13693 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13694          X"$as_dir" : 'X\(//\)[^/]' \| \
13695          X"$as_dir" : 'X\(//\)$' \| \
13696          X"$as_dir" : 'X\(/\)' \| \
13697          .     : '\(.\)' 2>/dev/null ||
13698 echo X"$as_dir" |
13699     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13700           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13701           /^X\(\/\/\)$/{ s//\1/; q; }
13702           /^X\(\/\).*/{ s//\1/; q; }
13703           s/.*/./; q'`
13704     done
13705     test ! -n "$as_dirs" || mkdir $as_dirs
13706   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13707 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13708    { (exit 1); exit 1; }; }; }
13709
13710   ac_builddir=.
13711
13712 if test "$ac_dir" != .; then
13713   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13714   # A "../" for each directory in $ac_dir_suffix.
13715   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13716 else
13717   ac_dir_suffix= ac_top_builddir=
13718 fi
13719
13720 case $srcdir in
13721   .)  # No --srcdir option.  We are building in place.
13722     ac_srcdir=.
13723     if test -z "$ac_top_builddir"; then
13724        ac_top_srcdir=.
13725     else
13726        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13727     fi ;;
13728   [\\/]* | ?:[\\/]* )  # Absolute path.
13729     ac_srcdir=$srcdir$ac_dir_suffix;
13730     ac_top_srcdir=$srcdir ;;
13731   *) # Relative path.
13732     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13733     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13734 esac
13735
13736 # Do not use `cd foo && pwd` to compute absolute paths, because
13737 # the directories may not exist.
13738 case `pwd` in
13739 .) ac_abs_builddir="$ac_dir";;
13740 *)
13741   case "$ac_dir" in
13742   .) ac_abs_builddir=`pwd`;;
13743   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13744   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13745   esac;;
13746 esac
13747 case $ac_abs_builddir in
13748 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13749 *)
13750   case ${ac_top_builddir}. in
13751   .) ac_abs_top_builddir=$ac_abs_builddir;;
13752   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13753   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13754   esac;;
13755 esac
13756 case $ac_abs_builddir in
13757 .) ac_abs_srcdir=$ac_srcdir;;
13758 *)
13759   case $ac_srcdir in
13760   .) ac_abs_srcdir=$ac_abs_builddir;;
13761   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13762   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13763   esac;;
13764 esac
13765 case $ac_abs_builddir in
13766 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13767 *)
13768   case $ac_top_srcdir in
13769   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13770   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13771   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13772   esac;;
13773 esac
13774
13775
13776   case $INSTALL in
13777   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13778   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13779   esac
13780
13781   if test x"$ac_file" != x-; then
13782     { echo "$as_me:$LINENO: creating $ac_file" >&5
13783 echo "$as_me: creating $ac_file" >&6;}
13784     rm -f "$ac_file"
13785   fi
13786   # Let's still pretend it is `configure' which instantiates (i.e., don't
13787   # use $as_me), people would be surprised to read:
13788   #    /* config.h.  Generated by config.status.  */
13789   if test x"$ac_file" = x-; then
13790     configure_input=
13791   else
13792     configure_input="$ac_file.  "
13793   fi
13794   configure_input=$configure_input"Generated from `echo $ac_file_in |
13795                                      sed 's,.*/,,'` by configure."
13796
13797   # First look for the input files in the build tree, otherwise in the
13798   # src tree.
13799   ac_file_inputs=`IFS=:
13800     for f in $ac_file_in; do
13801       case $f in
13802       -) echo $tmp/stdin ;;
13803       [\\/$]*)
13804          # Absolute (can't be DOS-style, as IFS=:)
13805          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13806 echo "$as_me: error: cannot find input file: $f" >&2;}
13807    { (exit 1); exit 1; }; }
13808          echo "$f";;
13809       *) # Relative
13810          if test -f "$f"; then
13811            # Build tree
13812            echo "$f"
13813          elif test -f "$srcdir/$f"; then
13814            # Source tree
13815            echo "$srcdir/$f"
13816          else
13817            # /dev/null tree
13818            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13819 echo "$as_me: error: cannot find input file: $f" >&2;}
13820    { (exit 1); exit 1; }; }
13821          fi;;
13822       esac
13823     done` || { (exit 1); exit 1; }
13824 _ACEOF
13825 cat >>$CONFIG_STATUS <<_ACEOF
13826   sed "$ac_vpsub
13827 $extrasub
13828 _ACEOF
13829 cat >>$CONFIG_STATUS <<\_ACEOF
13830 :t
13831 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13832 s,@configure_input@,$configure_input,;t t
13833 s,@srcdir@,$ac_srcdir,;t t
13834 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13835 s,@top_srcdir@,$ac_top_srcdir,;t t
13836 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13837 s,@builddir@,$ac_builddir,;t t
13838 s,@abs_builddir@,$ac_abs_builddir,;t t
13839 s,@top_builddir@,$ac_top_builddir,;t t
13840 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13841 s,@INSTALL@,$ac_INSTALL,;t t
13842 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13843   rm -f $tmp/stdin
13844   if test x"$ac_file" != x-; then
13845     mv $tmp/out $ac_file
13846   else
13847     cat $tmp/out
13848     rm -f $tmp/out
13849   fi
13850
13851 done
13852 _ACEOF
13853
13854 cat >>$CONFIG_STATUS <<\_ACEOF
13855
13856 { (exit 0); exit 0; }
13857 _ACEOF
13858 chmod +x $CONFIG_STATUS
13859 ac_clean_files=$ac_clean_files_save
13860
13861
13862 # configure is writing to config.log, and then calls config.status.
13863 # config.status does its own redirection, appending to config.log.
13864 # Unfortunately, on DOS this fails, as config.log is still kept open
13865 # by configure, so config.status won't be able to write to it; its
13866 # output is simply discarded.  So we exec the FD to /dev/null,
13867 # effectively closing config.log, so it can be properly (re)opened and
13868 # appended to by config.status.  When coming back to configure, we
13869 # need to make the FD available again.
13870 if test "$no_create" != yes; then
13871   ac_cs_success=:
13872   ac_config_status_args=
13873   test "$silent" = yes &&
13874     ac_config_status_args="$ac_config_status_args --quiet"
13875   exec 5>/dev/null
13876   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13877   exec 5>>config.log
13878   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13879   # would make configure fail if this is the last instruction.
13880   $ac_cs_success || { (exit 1); exit 1; }
13881 fi
13882