configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc extra_mpfr_configure_flags extra_mpc_gmp_configure_flags extra_mpc_mpfr_configure_flags stage1_ldflags stage1_libs poststage1_ldflags poststage1_libs ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir compare_exclusions LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-build-with-cxx build with C++ compiler instead of C compiler
 939   --disable-ppl-version-check    disable check for PPL version
 940   --disable-cloog-version-check  disable check for CLooG version
 941   --enable-stage1-languages[=all]   choose additional languages to build during
 942                           stage1.  Mostly useful for compiler development.
 943   --enable-objc-gc        enable use of Boehm's garbage collector with the
 944                           GNU Objective-C runtime
 945   --enable-bootstrap      enable bootstrapping [yes if native build]
 946   --enable-serial-[{host,target,build}-]configure
 947                           force sequential configuration of
 948                           sub-packages for the host, target or build
 949                           machine, or all sub-packages
 950   --enable-maintainer-mode enable make rules and dependencies not useful
 951                           (and sometimes confusing) to the casual installer
 952   --enable-stage1-checking[=all]   choose additional checking for stage1
 953                           of the compiler
 954   --enable-werror         enable -Werror in bootstrap stage2 and later
 955
 956 Optional Packages:
 957   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 958   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 959   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 960   --with-mpc=PATH        specify prefix directory for installed MPC package.
 961                           Equivalent to --with-mpc-include=PATH/include
 962                           plus --with-mpc-lib=PATH/lib
 963   --with-mpc-include=PATH
 964                           specify directory for installed MPC include files
 965   --with-mpc-lib=PATH    specify directory for the installed MPC library
 966   --with-mpfr-dir=PATH    this option has been REMOVED
 967   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 968                           Equivalent to --with-mpfr-include=PATH/include
 969                           plus --with-mpfr-lib=PATH/lib
 970   --with-mpfr-include=PATH
 971                           specify directory for installed MPFR include files
 972   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 973   --with-gmp-dir=PATH     this option has been REMOVED
 974   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 975                           Equivalent to --with-gmp-include=PATH/include
 976                           plus --with-gmp-lib=PATH/lib
 977   --with-gmp-include=PATH specify directory for installed GMP include files
 978   --with-gmp-lib=PATH     specify directory for the installed GMP library
 979   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 980                           when linking with PPL
 981   --with-stage1-ldflags=FLAGS Linker flags for stage1
 982   -with-stage1-libs=LIBS      Libraries for stage1
 983   --with-boot-ldflags=FLAGS Linker flags for stage2 and later
 984   --with-boot-libs=LIBS     Libraries for stage2 and later
 985   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 986                           Equivalent to --with-ppl-include=PATH/include
 987                           plus --with-ppl-lib=PATH/lib
 988   --with-ppl-include=PATH Specify directory for installed PPL include files
 989   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 990   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 991                           Equivalent to --with-cloog-include=PATH/include
 992                           plus --with-cloog-lib=PATH/lib
 993   --with-cloog-include=PATH Specify directory for installed CLooG include files
 994   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 995   --with-build-sysroot=SYSROOT
 996                           use sysroot as the system root during the build
 997   --with-debug-prefix-map='A=B C=D ...'
 998                              map A to B, C to D ... in debug information
 999   --with-build-time-tools=PATH
1000                           use given path to find target tools during the build
1001   --with-datarootdir      use datarootdir as the data root directory.
1002   --with-docdir           install documentation in this directory.
1003   --with-pdfdir           install pdf in this directory.
1004   --with-htmldir          install html in this directory.
1005
1006 Some influential environment variables:
1007   CC          C compiler command
1008   CFLAGS      C compiler flags
1009   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1010               nonstandard directory <lib dir>
1011   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1012               headers in a nonstandard directory <include dir>
1013   CXX         C++ compiler command
1014   CXXFLAGS    C++ compiler flags
1015   AR          AR for the host
1016   AS          AS for the host
1017   DLLTOOL     DLLTOOL for the host
1018   LD          LD for the host
1019   LIPO        LIPO for the host
1020   NM          NM for the host
1021   RANLIB      RANLIB for the host
1022   STRIP       STRIP for the host
1023   WINDRES     WINDRES for the host
1024   WINDMC      WINDMC for the host
1025   OBJCOPY     OBJCOPY for the host
1026   OBJDUMP     OBJDUMP for the host
1027   CC_FOR_TARGET
1028               CC for the target
1029   CXX_FOR_TARGET
1030               CXX for the target
1031   GCC_FOR_TARGET
1032               GCC for the target
1033   GCJ_FOR_TARGET
1034               GCJ for the target
1035   GFORTRAN_FOR_TARGET
1036               GFORTRAN for the target
1037   AR_FOR_TARGET
1038               AR for the target
1039   AS_FOR_TARGET
1040               AS for the target
1041   DLLTOOL_FOR_TARGET
1042               DLLTOOL for the target
1043   LD_FOR_TARGET
1044               LD for the target
1045   LIPO_FOR_TARGET
1046               LIPO for the target
1047   NM_FOR_TARGET
1048               NM for the target
1049   OBJDUMP_FOR_TARGET
1050               OBJDUMP for the target
1051   RANLIB_FOR_TARGET
1052               RANLIB for the target
1053   STRIP_FOR_TARGET
1054               STRIP for the target
1055   WINDRES_FOR_TARGET
1056               WINDRES for the target
1057   WINDMC_FOR_TARGET
1058               WINDMC for the target
1059
1060 Use these variables to override the choices made by `configure' or to help
1061 it to find libraries and programs with nonstandard names/locations.
1062
1063 _ACEOF
1064 fi
1065
1066 if test "$ac_init_help" = "recursive"; then
1067   # If there are subdirs, report their specific --help.
1068   ac_popdir=`pwd`
1069   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1070     test -d $ac_dir || continue
1071     ac_builddir=.
1072
1073 if test "$ac_dir" != .; then
1074   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1075   # A "../" for each directory in $ac_dir_suffix.
1076   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1077 else
1078   ac_dir_suffix= ac_top_builddir=
1079 fi
1080
1081 case $srcdir in
1082   .)  # No --srcdir option.  We are building in place.
1083     ac_srcdir=.
1084     if test -z "$ac_top_builddir"; then
1085        ac_top_srcdir=.
1086     else
1087        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1088     fi ;;
1089   [\\/]* | ?:[\\/]* )  # Absolute path.
1090     ac_srcdir=$srcdir$ac_dir_suffix;
1091     ac_top_srcdir=$srcdir ;;
1092   *) # Relative path.
1093     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1094     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1095 esac
1096
1097 # Do not use `cd foo && pwd` to compute absolute paths, because
1098 # the directories may not exist.
1099 case `pwd` in
1100 .) ac_abs_builddir="$ac_dir";;
1101 *)
1102   case "$ac_dir" in
1103   .) ac_abs_builddir=`pwd`;;
1104   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1105   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1106   esac;;
1107 esac
1108 case $ac_abs_builddir in
1109 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1110 *)
1111   case ${ac_top_builddir}. in
1112   .) ac_abs_top_builddir=$ac_abs_builddir;;
1113   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1114   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1115   esac;;
1116 esac
1117 case $ac_abs_builddir in
1118 .) ac_abs_srcdir=$ac_srcdir;;
1119 *)
1120   case $ac_srcdir in
1121   .) ac_abs_srcdir=$ac_abs_builddir;;
1122   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1123   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1124   esac;;
1125 esac
1126 case $ac_abs_builddir in
1127 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1128 *)
1129   case $ac_top_srcdir in
1130   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1131   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1132   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1133   esac;;
1134 esac
1135
1136     cd $ac_dir
1137     # Check for guested configure; otherwise get Cygnus style configure.
1138     if test -f $ac_srcdir/configure.gnu; then
1139       echo
1140       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1141     elif test -f $ac_srcdir/configure; then
1142       echo
1143       $SHELL $ac_srcdir/configure  --help=recursive
1144     elif test -f $ac_srcdir/configure.ac ||
1145            test -f $ac_srcdir/configure.in; then
1146       echo
1147       $ac_configure --help
1148     else
1149       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1150     fi
1151     cd $ac_popdir
1152   done
1153 fi
1154
1155 test -n "$ac_init_help" && exit 0
1156 if $ac_init_version; then
1157   cat <<\_ACEOF
1158
1159 Copyright (C) 2003 Free Software Foundation, Inc.
1160 This configure script is free software; the Free Software Foundation
1161 gives unlimited permission to copy, distribute and modify it.
1162 _ACEOF
1163   exit 0
1164 fi
1165 exec 5>config.log
1166 cat >&5 <<_ACEOF
1167 This file contains any messages produced by compilers while
1168 running configure, to aid debugging if configure makes a mistake.
1169
1170 It was created by $as_me, which was
1171 generated by GNU Autoconf 2.59.  Invocation command line was
1172
1173   $ $0 $@
1174
1175 _ACEOF
1176 {
1177 cat <<_ASUNAME
1178 ## --------- ##
1179 ## Platform. ##
1180 ## --------- ##
1181
1182 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1183 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1184 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1185 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1186 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1187
1188 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1189 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1190
1191 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1192 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1193 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1194 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1195 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1196 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1197 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1198
1199 _ASUNAME
1200
1201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1202 for as_dir in $PATH
1203 do
1204   IFS=$as_save_IFS
1205   test -z "$as_dir" && as_dir=.
1206   echo "PATH: $as_dir"
1207 done
1208
1209 } >&5
1210
1211 cat >&5 <<_ACEOF
1212
1213
1214 ## ----------- ##
1215 ## Core tests. ##
1216 ## ----------- ##
1217
1218 _ACEOF
1219
1220
1221 # Keep a trace of the command line.
1222 # Strip out --no-create and --no-recursion so they do not pile up.
1223 # Strip out --silent because we don't want to record it for future runs.
1224 # Also quote any args containing shell meta-characters.
1225 # Make two passes to allow for proper duplicate-argument suppression.
1226 ac_configure_args=
1227 ac_configure_args0=
1228 ac_configure_args1=
1229 ac_sep=
1230 ac_must_keep_next=false
1231 for ac_pass in 1 2
1232 do
1233   for ac_arg
1234   do
1235     case $ac_arg in
1236     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1237     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1238     | -silent | --silent | --silen | --sile | --sil)
1239       continue ;;
1240     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1241       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1242     esac
1243     case $ac_pass in
1244     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1245     2)
1246       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1247       if test $ac_must_keep_next = true; then
1248         ac_must_keep_next=false # Got value, back to normal.
1249       else
1250         case $ac_arg in
1251           *=* | --config-cache | -C | -disable-* | --disable-* \
1252           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1253           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1254           | -with-* | --with-* | -without-* | --without-* | --x)
1255             case "$ac_configure_args0 " in
1256               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1257             esac
1258             ;;
1259           -* ) ac_must_keep_next=true ;;
1260         esac
1261       fi
1262       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1263       # Get rid of the leading space.
1264       ac_sep=" "
1265       ;;
1266     esac
1267   done
1268 done
1269 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1270 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1271
1272 # When interrupted or exit'd, cleanup temporary files, and complete
1273 # config.log.  We remove comments because anyway the quotes in there
1274 # would cause problems or look ugly.
1275 # WARNING: Be sure not to use single quotes in there, as some shells,
1276 # such as our DU 5.0 friend, will then `close' the trap.
1277 trap 'exit_status=$?
1278   # Save into config.log some information that might help in debugging.
1279   {
1280     echo
1281
1282     cat <<\_ASBOX
1283 ## ---------------- ##
1284 ## Cache variables. ##
1285 ## ---------------- ##
1286 _ASBOX
1287     echo
1288     # The following way of writing the cache mishandles newlines in values,
1289 {
1290   (set) 2>&1 |
1291     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1292     *ac_space=\ *)
1293       sed -n \
1294         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1295           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1296       ;;
1297     *)
1298       sed -n \
1299         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1300       ;;
1301     esac;
1302 }
1303     echo
1304
1305     cat <<\_ASBOX
1306 ## ----------------- ##
1307 ## Output variables. ##
1308 ## ----------------- ##
1309 _ASBOX
1310     echo
1311     for ac_var in $ac_subst_vars
1312     do
1313       eval ac_val=$`echo $ac_var`
1314       echo "$ac_var='"'"'$ac_val'"'"'"
1315     done | sort
1316     echo
1317
1318     if test -n "$ac_subst_files"; then
1319       cat <<\_ASBOX
1320 ## ------------- ##
1321 ## Output files. ##
1322 ## ------------- ##
1323 _ASBOX
1324       echo
1325       for ac_var in $ac_subst_files
1326       do
1327         eval ac_val=$`echo $ac_var`
1328         echo "$ac_var='"'"'$ac_val'"'"'"
1329       done | sort
1330       echo
1331     fi
1332
1333     if test -s confdefs.h; then
1334       cat <<\_ASBOX
1335 ## ----------- ##
1336 ## confdefs.h. ##
1337 ## ----------- ##
1338 _ASBOX
1339       echo
1340       sed "/^$/d" confdefs.h | sort
1341       echo
1342     fi
1343     test "$ac_signal" != 0 &&
1344       echo "$as_me: caught signal $ac_signal"
1345     echo "$as_me: exit $exit_status"
1346   } >&5
1347   rm -f core *.core &&
1348   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1349     exit $exit_status
1350      ' 0
1351 for ac_signal in 1 2 13 15; do
1352   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1353 done
1354 ac_signal=0
1355
1356 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1357 rm -rf conftest* confdefs.h
1358 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1359 echo >confdefs.h
1360
1361 # Predefined preprocessor variables.
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_NAME "$PACKAGE_NAME"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_STRING "$PACKAGE_STRING"
1380 _ACEOF
1381
1382
1383 cat >>confdefs.h <<_ACEOF
1384 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1385 _ACEOF
1386
1387
1388 # Let the site file select an alternate cache file if it wants to.
1389 # Prefer explicitly selected file to automatically selected ones.
1390 if test -z "$CONFIG_SITE"; then
1391   if test "x$prefix" != xNONE; then
1392     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1393   else
1394     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1395   fi
1396 fi
1397 for ac_site_file in $CONFIG_SITE; do
1398   if test -r "$ac_site_file"; then
1399     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1400 echo "$as_me: loading site script $ac_site_file" >&6;}
1401     sed 's/^/| /' "$ac_site_file" >&5
1402     . "$ac_site_file"
1403   fi
1404 done
1405
1406 if test -r "$cache_file"; then
1407   # Some versions of bash will fail to source /dev/null (special
1408   # files actually), so we avoid doing that.
1409   if test -f "$cache_file"; then
1410     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1411 echo "$as_me: loading cache $cache_file" >&6;}
1412     case $cache_file in
1413       [\\/]* | ?:[\\/]* ) . $cache_file;;
1414       *)                      . ./$cache_file;;
1415     esac
1416   fi
1417 else
1418   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1419 echo "$as_me: creating cache $cache_file" >&6;}
1420   >$cache_file
1421 fi
1422
1423 # Check that the precious variables saved in the cache have kept the same
1424 # value.
1425 ac_cache_corrupted=false
1426 for ac_var in `(set) 2>&1 |
1427                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1428   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1429   eval ac_new_set=\$ac_env_${ac_var}_set
1430   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1431   eval ac_new_val="\$ac_env_${ac_var}_value"
1432   case $ac_old_set,$ac_new_set in
1433     set,)
1434       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1435 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1436       ac_cache_corrupted=: ;;
1437     ,set)
1438       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1439 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1440       ac_cache_corrupted=: ;;
1441     ,);;
1442     *)
1443       if test "x$ac_old_val" != "x$ac_new_val"; then
1444         # differences in whitespace do not lead to failure.
1445         ac_old_val_w=`echo x $ac_old_val`
1446         ac_new_val_w=`echo x $ac_new_val`
1447         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1448           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1449 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1450           ac_cache_corrupted=:
1451         else
1452           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1453 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1454           eval $ac_var=\$ac_old_val
1455         fi
1456         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1457 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1458         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1459 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1460       fi;;
1461   esac
1462   # Pass precious variables to config.status.
1463   if test "$ac_new_set" = set; then
1464     case $ac_new_val in
1465     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1466       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1467     *) ac_arg=$ac_var=$ac_new_val ;;
1468     esac
1469     case " $ac_configure_args " in
1470       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1471       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1472     esac
1473   fi
1474 done
1475 if $ac_cache_corrupted; then
1476   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1477 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1478   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1479 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1480   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1481 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1482    { (exit 1); exit 1; }; }
1483 fi
1484
1485 ac_ext=c
1486 ac_cpp='$CPP $CPPFLAGS'
1487 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1488 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1489 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514 progname=$0
1515 # if PWD already has a value, it is probably wrong.
1516 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1517
1518 # Export original configure arguments for use by sub-configures.
1519 # Quote arguments with shell meta charatcers.
1520 TOPLEVEL_CONFIGURE_ARGUMENTS=
1521 set -- "$progname" "$@"
1522 for ac_arg
1523 do
1524   case "$ac_arg" in
1525   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1526     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1527     # if the argument is of the form -foo=baz, quote the baz part only
1528     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1529   *) ;;
1530   esac
1531   # Add the quoted argument to the list.
1532   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1533 done
1534 if test "$silent" = yes; then
1535   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1536 fi
1537 # Remove the initial space we just introduced and, as these will be
1538 # expanded by make, quote '$'.
1539 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1540
1541
1542 # Find the build, host, and target systems.
1543 ac_aux_dir=
1544 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1545   if test -f $ac_dir/install-sh; then
1546     ac_aux_dir=$ac_dir
1547     ac_install_sh="$ac_aux_dir/install-sh -c"
1548     break
1549   elif test -f $ac_dir/install.sh; then
1550     ac_aux_dir=$ac_dir
1551     ac_install_sh="$ac_aux_dir/install.sh -c"
1552     break
1553   elif test -f $ac_dir/shtool; then
1554     ac_aux_dir=$ac_dir
1555     ac_install_sh="$ac_aux_dir/shtool install -c"
1556     break
1557   fi
1558 done
1559 if test -z "$ac_aux_dir"; then
1560   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1561 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1562    { (exit 1); exit 1; }; }
1563 fi
1564 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1565 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1566 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1567
1568 # Make sure we can run config.sub.
1569 $ac_config_sub sun4 >/dev/null 2>&1 ||
1570   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1571 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1572    { (exit 1); exit 1; }; }
1573
1574 echo "$as_me:$LINENO: checking build system type" >&5
1575 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1576 if test "${ac_cv_build+set}" = set; then
1577   echo $ECHO_N "(cached) $ECHO_C" >&6
1578 else
1579   ac_cv_build_alias=$build_alias
1580 test -z "$ac_cv_build_alias" &&
1581   ac_cv_build_alias=`$ac_config_guess`
1582 test -z "$ac_cv_build_alias" &&
1583   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1584 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1585    { (exit 1); exit 1; }; }
1586 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1593 echo "${ECHO_T}$ac_cv_build" >&6
1594 build=$ac_cv_build
1595 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600  case ${build_alias} in
1601   "") build_noncanonical=${build} ;;
1602   *) build_noncanonical=${build_alias} ;;
1603 esac
1604
1605
1606
1607  case ${host_alias} in
1608   "") host_noncanonical=${build_noncanonical} ;;
1609   *) host_noncanonical=${host_alias} ;;
1610 esac
1611
1612
1613
1614  case ${target_alias} in
1615   "") target_noncanonical=${host_noncanonical} ;;
1616   *) target_noncanonical=${target_alias} ;;
1617 esac
1618
1619
1620
1621
1622 test "$host_noncanonical" = "$target_noncanonical" &&
1623   test "$program_prefix$program_suffix$program_transform_name" = \
1624     NONENONEs,x,x, &&
1625   program_transform_name=s,y,y,
1626
1627 echo "$as_me:$LINENO: checking host system type" >&5
1628 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1629 if test "${ac_cv_host+set}" = set; then
1630   echo $ECHO_N "(cached) $ECHO_C" >&6
1631 else
1632   ac_cv_host_alias=$host_alias
1633 test -z "$ac_cv_host_alias" &&
1634   ac_cv_host_alias=$ac_cv_build_alias
1635 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1636   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1637 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1638    { (exit 1); exit 1; }; }
1639
1640 fi
1641 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1642 echo "${ECHO_T}$ac_cv_host" >&6
1643 host=$ac_cv_host
1644 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1645 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1646 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1647
1648
1649 echo "$as_me:$LINENO: checking target system type" >&5
1650 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1651 if test "${ac_cv_target+set}" = set; then
1652   echo $ECHO_N "(cached) $ECHO_C" >&6
1653 else
1654   ac_cv_target_alias=$target_alias
1655 test "x$ac_cv_target_alias" = "x" &&
1656   ac_cv_target_alias=$ac_cv_host_alias
1657 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1658   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1659 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1660    { (exit 1); exit 1; }; }
1661
1662 fi
1663 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1664 echo "${ECHO_T}$ac_cv_target" >&6
1665 target=$ac_cv_target
1666 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1667 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1668 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1669
1670
1671 # The aliases save the names the user supplied, while $host etc.
1672 # will get canonicalized.
1673 test -n "$target_alias" &&
1674   test "$program_prefix$program_suffix$program_transform_name" = \
1675     NONENONEs,x,x, &&
1676   program_prefix=${target_alias}-
1677 test "$program_prefix" != NONE &&
1678   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1679 # Use a double $ so make ignores it.
1680 test "$program_suffix" != NONE &&
1681   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1682 # Double any \ or $.  echo might interpret backslashes.
1683 # By default was `s,x,x', remove it if useless.
1684 cat <<\_ACEOF >conftest.sed
1685 s/[\\$]/&&/g;s/;s,x,x,$//
1686 _ACEOF
1687 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1688 rm conftest.sed
1689
1690
1691
1692 # Get 'install' or 'install-sh' and its variants.
1693 # Find a good install program.  We prefer a C program (faster),
1694 # so one script is as good as another.  But avoid the broken or
1695 # incompatible versions:
1696 # SysV /etc/install, /usr/sbin/install
1697 # SunOS /usr/etc/install
1698 # IRIX /sbin/install
1699 # AIX /bin/install
1700 # AmigaOS /C/install, which installs bootblocks on floppy discs
1701 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1702 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1703 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1704 # OS/2's system install, which has a completely different semantic
1705 # ./install, which can be erroneously created by make from ./install.sh.
1706 # Reject install programs that cannot install multiple files.
1707 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1708 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1709 if test -z "$INSTALL"; then
1710 if test "${ac_cv_path_install+set}" = set; then
1711   echo $ECHO_N "(cached) $ECHO_C" >&6
1712 else
1713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1714 for as_dir in $PATH
1715 do
1716   IFS=$as_save_IFS
1717   test -z "$as_dir" && as_dir=.
1718   # Account for people who put trailing slashes in PATH elements.
1719 case $as_dir/ in
1720   ./ | .// | /cC/* | \
1721   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1722   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1723   /usr/ucb/* ) ;;
1724   *)
1725     # OSF1 and SCO ODT 3.0 have their own names for install.
1726     # Don't use installbsd from OSF since it installs stuff as root
1727     # by default.
1728     for ac_prog in ginstall scoinst install; do
1729       for ac_exec_ext in '' $ac_executable_extensions; do
1730         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1731           if test $ac_prog = install &&
1732             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1733             # AIX install.  It has an incompatible calling convention.
1734             :
1735           elif test $ac_prog = install &&
1736             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1737             # program-specific install script used by HP pwplus--don't use.
1738             :
1739           else
1740             rm -rf conftest.one conftest.two conftest.dir
1741             echo one > conftest.one
1742             echo two > conftest.two
1743             mkdir conftest.dir
1744             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1745               test -s conftest.one && test -s conftest.two &&
1746               test -s conftest.dir/conftest.one &&
1747               test -s conftest.dir/conftest.two
1748             then
1749               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1750               break 3
1751             fi
1752           fi
1753         fi
1754       done
1755     done
1756     ;;
1757 esac
1758 done
1759
1760 rm -rf conftest.one conftest.two conftest.dir
1761
1762 fi
1763   if test "${ac_cv_path_install+set}" = set; then
1764     INSTALL=$ac_cv_path_install
1765   else
1766     # As a last resort, use the slow shell script.  Don't cache a
1767     # value for INSTALL within a source directory, because that will
1768     # break other packages using the cache if that directory is
1769     # removed, or if the value is a relative name.
1770     INSTALL=$ac_install_sh
1771   fi
1772 fi
1773 echo "$as_me:$LINENO: result: $INSTALL" >&5
1774 echo "${ECHO_T}$INSTALL" >&6
1775
1776 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1777 # It thinks the first close brace ends the variable substitution.
1778 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1779
1780 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1781
1782 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1783
1784 echo "$as_me:$LINENO: checking whether ln works" >&5
1785 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1786 if test "${acx_cv_prog_LN+set}" = set; then
1787   echo $ECHO_N "(cached) $ECHO_C" >&6
1788 else
1789   rm -f conftestdata_t
1790 echo >conftestdata_f
1791 if ln conftestdata_f conftestdata_t 2>/dev/null
1792 then
1793   acx_cv_prog_LN=ln
1794 else
1795   acx_cv_prog_LN=no
1796 fi
1797 rm -f conftestdata_f conftestdata_t
1798
1799 fi
1800 if test $acx_cv_prog_LN = no; then
1801   LN="cp"
1802   echo "$as_me:$LINENO: result: no, using $LN" >&5
1803 echo "${ECHO_T}no, using $LN" >&6
1804 else
1805   LN="$acx_cv_prog_LN"
1806   echo "$as_me:$LINENO: result: yes" >&5
1807 echo "${ECHO_T}yes" >&6
1808 fi
1809
1810 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1811 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1812 LN_S=$as_ln_s
1813 if test "$LN_S" = "ln -s"; then
1814   echo "$as_me:$LINENO: result: yes" >&5
1815 echo "${ECHO_T}yes" >&6
1816 else
1817   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1818 echo "${ECHO_T}no, using $LN_S" >&6
1819 fi
1820
1821
1822 ### we might need to use some other shell than /bin/sh for running subshells
1823 ### If we are on Windows, search for the shell.  This will permit people
1824 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1825 ### without also having to set CONFIG_SHELL.  This code will work when
1826 ### using bash, which sets OSTYPE.
1827 case "${OSTYPE}" in
1828 *win32*)
1829   if test x${CONFIG_SHELL} = x ; then
1830     if test ! -f /bin/sh ; then
1831       if test x${SHELL} != x && test -f ${SHELL} ; then
1832         CONFIG_SHELL=${SHELL}
1833         export CONFIG_SHELL
1834       else
1835         for prog in sh sh.exe bash bash.exe; do
1836           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1837           for dir in $PATH; do
1838             test -z "$dir" && dir=.
1839             if test -f $dir/$prog; then
1840               CONFIG_SHELL=$dir/$prog
1841               export CONFIG_SHELL
1842               break
1843             fi
1844           done
1845           IFS="$save_ifs"
1846           test -n "${CONFIG_SHELL}" && break
1847         done
1848       fi
1849     fi
1850   fi
1851   ;;
1852 esac
1853
1854 config_shell=${CONFIG_SHELL-/bin/sh}
1855
1856 moveifchange=${srcdir}/move-if-change
1857
1858 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1859
1860 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1861 # a relative path.
1862 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1863   INSTALL="${srcpwd}/install-sh -c"
1864 fi
1865
1866 # Set srcdir to "." if that's what it is.
1867 # This is important for multilib support.
1868 pwd=`${PWDCMD-pwd}`
1869 if test "${pwd}" = "${srcpwd}" ; then
1870   srcdir=.
1871 fi
1872
1873 topsrcdir=$srcpwd
1874
1875 extra_host_args=
1876
1877 ### To add a new directory to the tree, first choose whether it is a target
1878 ### or a host dependent tool.  Then put it into the appropriate list
1879 ### (library or tools, host or target), doing a dependency sort.
1880
1881 # Subdirs will be configured in the order listed in build_configdirs,
1882 # configdirs, or target_configdirs; see the serialization section below.
1883
1884 # Dependency sorting is only needed when *configuration* must be done in
1885 # a particular order.  In all cases a dependency should be specified in
1886 # the Makefile, whether or not it's implicitly specified here.
1887
1888 # Double entries in build_configdirs, configdirs, or target_configdirs may
1889 # cause circular dependencies and break everything horribly.
1890
1891 # these library is used by various programs built for the build
1892 # environment
1893 #
1894 build_libs="build-libiberty"
1895
1896 # these tools are built for the build environment
1897 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1898
1899 # these libraries are used by various programs built for the host environment
1900 #
1901 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1902
1903 # these tools are built for the host environment
1904 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1905 # know that we are building the simulator.
1906 # binutils, gas and ld appear in that order because it makes sense to run
1907 # "make check" in that particular order.
1908 # If --enable-gold is used, "gold" will replace "ld".
1909 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc cgen sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1910
1911 # libgcj represents the runtime libraries only used by gcj.
1912 libgcj="target-libffi \
1913         target-zlib \
1914         target-qthreads \
1915         target-libjava"
1916
1917 # these libraries are built for the target environment, and are built after
1918 # the host libraries and the host tools (which may be a cross compiler)
1919 #
1920 target_libraries="target-libgcc \
1921                 target-libiberty \
1922                 target-libgloss \
1923                 target-newlib \
1924                 target-libgomp \
1925                 target-libstdc++-v3 \
1926                 target-libmudflap \
1927                 target-libssp \
1928                 target-libgfortran \
1929                 target-boehm-gc \
1930                 ${libgcj} \
1931                 target-libobjc \
1932                 target-libada"
1933
1934 # these tools are built using the target libraries, and are intended to
1935 # run only in the target environment
1936 #
1937 # note: any program that *uses* libraries that are in the "target_libraries"
1938 # list belongs in this list.  those programs are also very likely
1939 # candidates for the "native_only" list which follows
1940 #
1941 target_tools="target-examples target-groff target-gperf target-rda"
1942
1943 ################################################################################
1944
1945 ## All tools belong in one of the four categories, and are assigned above
1946 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1947 ## is important because configure will choke if they ever get through.
1948 ## ${configdirs} is directories we build using the host tools.
1949 ## ${target_configdirs} is directories we build using the target tools.
1950 configdirs=`echo ${host_libs} ${host_tools}`
1951 target_configdirs=`echo ${target_libraries} ${target_tools}`
1952 build_configdirs=`echo ${build_libs} ${build_tools}`
1953
1954
1955
1956 ################################################################################
1957
1958 srcname="gnu development package"
1959
1960 # This gets set non-empty for some net releases of packages.
1961 appdirs=""
1962
1963 # Define is_cross_compiler to save on calls to 'test'.
1964 is_cross_compiler=
1965 if test x"${host}" = x"${target}" ; then
1966   is_cross_compiler=no
1967 else
1968   is_cross_compiler=yes
1969 fi
1970
1971 # Find the build and target subdir names.
1972
1973 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1974 # have matching libraries, they should use host libraries: Makefile.tpl
1975 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1976 # However, they still use the build modules, because the corresponding
1977 # host modules (e.g. bison) are only built for the host when bootstrap
1978 # finishes. So:
1979 # - build_subdir is where we find build modules, and never changes.
1980 # - build_libsubdir is where we find build libraries, and can be overridden.
1981
1982 # Prefix 'build-' so this never conflicts with target_subdir.
1983 build_subdir="build-${build_noncanonical}"
1984
1985 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1986 if test "${with_build_libsubdir+set}" = set; then
1987   withval="$with_build_libsubdir"
1988   build_libsubdir="$withval"
1989 else
1990   build_libsubdir="$build_subdir"
1991 fi;
1992 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1993 if ( test $srcdir = . && test -d gcc ) \
1994    || test -d $srcdir/../host-${host_noncanonical}; then
1995   host_subdir="host-${host_noncanonical}"
1996 else
1997   host_subdir=.
1998 fi
1999 # No prefix.
2000 target_subdir=${target_noncanonical}
2001
2002
2003 # Skipdirs are removed silently.
2004 skipdirs=
2005 # Noconfigdirs are removed loudly.
2006 noconfigdirs=""
2007
2008 use_gnu_ld=
2009 # Make sure we don't let GNU ld be added if we didn't want it.
2010 if test x$with_gnu_ld = xno ; then
2011   use_gnu_ld=no
2012   noconfigdirs="$noconfigdirs ld gold"
2013 fi
2014
2015 use_gnu_as=
2016 # Make sure we don't let GNU as be added if we didn't want it.
2017 if test x$with_gnu_as = xno ; then
2018   use_gnu_as=no
2019   noconfigdirs="$noconfigdirs gas"
2020 fi
2021
2022 # some tools are so dependent upon X11 that if we're not building with X,
2023 # it's not even worth trying to configure, much less build, that tool.
2024
2025 case ${with_x} in
2026   yes | "") ;; # the default value for this tree is that X11 is available
2027   no)
2028     skipdirs="${skipdirs} tk itcl libgui"
2029     # We won't be able to build gdbtk without X.
2030     enable_gdbtk=no
2031     ;;
2032   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2033 esac
2034
2035 # Some tools are only suitable for building in a "native" situation.
2036 # Remove these if host!=target.
2037 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2038
2039 # Similarly, some are only suitable for cross toolchains.
2040 # Remove these if host=target.
2041 cross_only="target-libgloss target-newlib target-opcodes"
2042
2043 case $is_cross_compiler in
2044   no) skipdirs="${skipdirs} ${cross_only}" ;;
2045   yes) skipdirs="${skipdirs} ${native_only}" ;;
2046 esac
2047
2048 # If both --with-headers and --with-libs are specified, default to
2049 # --without-newlib.
2050 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2051    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2052   if test x"${with_newlib}" = x ; then
2053     with_newlib=no
2054   fi
2055 fi
2056
2057 # Recognize --with-newlib/--without-newlib.
2058 case ${with_newlib} in
2059   no) skipdirs="${skipdirs} target-newlib" ;;
2060   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2061 esac
2062
2063 # Handle --enable-gold.
2064
2065 # Check whether --enable-gold or --disable-gold was given.
2066 if test "${enable_gold+set}" = set; then
2067   enableval="$enable_gold"
2068   ENABLE_GOLD=$enableval
2069 else
2070   ENABLE_GOLD=no
2071 fi;
2072 if test "${ENABLE_GOLD}" = "yes"; then
2073   # Check for ELF target.
2074   is_elf=no
2075   case "${target}" in
2076     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2077     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2078     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2079       case "${target}" in
2080         *-*-linux*aout* | *-*-linux*oldld*)
2081           ;;
2082         *)
2083           is_elf=yes
2084           ;;
2085       esac
2086   esac
2087
2088   if test "$is_elf" = "yes"; then
2089     # Check for target supported by gold.
2090     case "${target}" in
2091       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2092         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2093         ;;
2094     esac
2095   fi
2096 fi
2097
2098 # Configure extra directories which are host specific
2099
2100 case "${host}" in
2101   *-cygwin*)
2102     configdirs="$configdirs libtermcap" ;;
2103 esac
2104
2105 # A target can indicate whether a language isn't supported for some reason.
2106 # Only spaces may be used in this macro; not newlines or tabs.
2107 unsupported_languages=
2108
2109 # Remove more programs from consideration, based on the host or
2110 # target this usually means that a port of the program doesn't
2111 # exist yet.
2112
2113 case "${host}" in
2114   hppa*64*-*-*)
2115     noconfigdirs="$noconfigdirs byacc"
2116     ;;
2117   i[3456789]86-*-vsta)
2118     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2119     ;;
2120   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2121     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2122     ;;
2123   x86_64-*-mingw*)
2124     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2125     ;;
2126   i[3456789]86-*-mingw32*)
2127     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2128     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2129     ;;
2130   i[3456789]86-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2132     ;;
2133   *-*-cygwin*)
2134     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2135     ;;
2136   *-*-netbsd*)
2137     noconfigdirs="$noconfigdirs rcs"
2138     ;;
2139   ppc*-*-pe)
2140     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2141     ;;
2142   powerpc-*-beos*)
2143     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2144     ;;
2145 esac
2146
2147
2148 # Check whether --enable-libada or --disable-libada was given.
2149 if test "${enable_libada+set}" = set; then
2150   enableval="$enable_libada"
2151   ENABLE_LIBADA=$enableval
2152 else
2153   ENABLE_LIBADA=yes
2154 fi;
2155 if test "${ENABLE_LIBADA}" != "yes" ; then
2156   noconfigdirs="$noconfigdirs gnattools"
2157 fi
2158
2159 # Check whether --enable-libssp or --disable-libssp was given.
2160 if test "${enable_libssp+set}" = set; then
2161   enableval="$enable_libssp"
2162   ENABLE_LIBSSP=$enableval
2163 else
2164   ENABLE_LIBSSP=yes
2165 fi;
2166
2167 # Save it here so that, even in case of --enable-libgcj, if the Java
2168 # front-end isn't enabled, we still get libgcj disabled.
2169 libgcj_saved=$libgcj
2170 case $enable_libgcj in
2171 yes)
2172   # If we reset it here, it won't get added to noconfigdirs in the
2173   # target-specific build rules, so it will be forcibly enabled
2174   # (unless the Java language itself isn't enabled).
2175   libgcj=
2176   ;;
2177 no)
2178   # Make sure we get it printed in the list of not supported target libs.
2179   noconfigdirs="$noconfigdirs ${libgcj}"
2180   ;;
2181 esac
2182
2183
2184 # Disable libmudflap on some systems.
2185 if test x$enable_libmudflap = x ; then
2186     case "${target}" in
2187     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2188         # Enable libmudflap by default in GNU and friends.
2189         ;;
2190     *-*-freebsd*)
2191         # Enable libmudflap by default in FreeBSD.
2192         ;;
2193     *)
2194         # Disable it by default everywhere else.
2195         noconfigdirs="$noconfigdirs target-libmudflap"
2196         ;;
2197     esac
2198 fi
2199
2200 # Disable libgomp on non POSIX hosted systems.
2201 if test x$enable_libgomp = x ; then
2202     # Enable libgomp by default on hosted POSIX systems.
2203     case "${target}" in
2204     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2205         ;;
2206     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2207         ;;
2208     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2209         ;;
2210     *-*-darwin* | *-*-aix*)
2211         ;;
2212     *)
2213         noconfigdirs="$noconfigdirs target-libgomp"
2214         ;;
2215     esac
2216 fi
2217
2218 # Default libgloss CPU subdirectory.
2219 libgloss_dir="$target_cpu"
2220
2221 case "${target}" in
2222   *-*-chorusos)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   powerpc-*-darwin*)
2226     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2227     noconfigdirs="$noconfigdirs sim target-rda"
2228     ;;
2229   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2230     noconfigdirs="$noconfigdirs ld gas gprof"
2231     noconfigdirs="$noconfigdirs sim target-rda"
2232     ;;
2233   *-*-darwin*)
2234     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2235     noconfigdirs="$noconfigdirs sim target-rda"
2236     noconfigdirs="$noconfigdirs ${libgcj}"
2237     ;;
2238   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2239     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2240     ;;
2241   *-*-freebsd*)
2242     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2243     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2244         && test -f /usr/local/include/gmp.h; then
2245       with_gmp=/usr/local
2246     fi
2247
2248     # Skip some stuff that's unsupported on some FreeBSD configurations.
2249     case "${target}" in
2250       i*86-*-*) ;;
2251       alpha*-*-*) ;;
2252       *)
2253         noconfigdirs="$noconfigdirs ${libgcj}"
2254         ;;
2255     esac
2256     ;;
2257   *-*-kaos*)
2258     # Remove unsupported stuff on all kaOS configurations.
2259     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2260     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2261     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2262     noconfigdirs="$noconfigdirs target-libgloss"
2263     ;;
2264   *-*-netbsd*)
2265     # Skip some stuff on all NetBSD configurations.
2266     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2267
2268     # Skip some stuff that's unsupported on some NetBSD configurations.
2269     case "${target}" in
2270       i*86-*-netbsdelf*) ;;
2271       arm*-*-netbsdelf*) ;;
2272       *)
2273         noconfigdirs="$noconfigdirs ${libgcj}"
2274         ;;
2275     esac
2276     ;;
2277   *-*-netware*)
2278     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2279     ;;
2280   *-*-rtems*)
2281     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2282     ;;
2283     # The tpf target doesn't support gdb yet.
2284   *-*-tpf*)
2285     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2286     ;;
2287   *-*-uclinux*)
2288     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2289     ;;
2290   *-*-vxworks*)
2291     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2292     ;;
2293   alpha*-dec-osf*)
2294     # ld works, but does not support shared libraries.
2295     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2296     # gas doesn't generate exception information.
2297     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2298     ;;
2299   alpha*-*-*vms*)
2300     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2301     ;;
2302   alpha*-*-linux*)
2303     # newlib is not 64 bit ready
2304     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2305     ;;
2306   alpha*-*-*)
2307     # newlib is not 64 bit ready
2308     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2309     ;;
2310   am33_2.0-*-linux*)
2311     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2312     ;;
2313   sh-*-linux*)
2314     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2315     ;;
2316   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2317     noconfigdirs="$noconfigdirs ${libgcj}"
2318     noconfigdirs="$noconfigdirs target-examples"
2319     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2320     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2321     noconfigdirs="$noconfigdirs expect dejagnu"
2322     # the C++ libraries don't build on top of CE's C libraries
2323     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2324     noconfigdirs="$noconfigdirs target-newlib"
2325     case "${host}" in
2326       *-*-cygwin*) ;; # keep gdb and readline
2327       *) noconfigdirs="$noconfigdirs gdb readline"
2328          ;;
2329     esac
2330     libgloss_dir=wince
2331     ;;
2332   arc-*-*)
2333     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2334     ;;
2335   arm-semi-aof )
2336     ;;
2337   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2338     noconfigdirs="$noconfigdirs ${libgcj}"
2339     libgloss_dir=arm
2340     ;;
2341   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2342     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2343     libgloss_dir=arm
2344     ;;
2345   arm*-*-linux-gnueabi)
2346     noconfigdirs="$noconfigdirs target-qthreads"
2347     case ${with_newlib} in
2348       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2349     esac
2350     libgloss_dir=arm
2351     ;;
2352   arm*-*-symbianelf*)
2353     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2354     libgloss_dir=arm
2355     ;;
2356   arm-*-pe*)
2357     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2358     ;;
2359   thumb-*-coff)
2360     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2361     ;;
2362   thumb-*-elf)
2363     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2364     ;;
2365   thumb-*-pe)
2366     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2367     ;;
2368   arm-*-riscix*)
2369     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2370     ;;
2371   avr-*-*)
2372     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2373     ;;
2374   bfin-*-*)
2375     noconfigdirs="$noconfigdirs gdb"
2376     if test x${is_cross_compiler} != xno ; then
2377       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2378     fi
2379     ;;
2380   c4x-*-* | tic4x-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   c54x*-*-* | tic54x-*-*)
2384     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2385     ;;
2386   cr16-*-*)
2387     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2388     ;;
2389   cris-*-* | crisv32-*-*)
2390     unsupported_languages="$unsupported_languages java"
2391     case "${target}" in
2392       *-*-aout)
2393         unsupported_languages="$unsupported_languages fortran"
2394         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2395       *-*-elf)
2396         noconfigdirs="$noconfigdirs target-boehm-gc";;
2397       *-*-linux*)
2398         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2399       *)
2400         unsupported_languages="$unsupported_languages fortran"
2401         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2402     esac
2403     libgloss_dir=cris
2404     ;;
2405   crx-*-*)
2406     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2407     ;;
2408   d10v-*-*)
2409     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2410     ;;
2411   d30v-*-*)
2412     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2413     ;;
2414   ep9312-*-elf | ep9312-*-coff)
2415     libgloss_dir=arm
2416     ;;
2417   fr30-*-elf*)
2418     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2419     ;;
2420   frv-*-*)
2421     noconfigdirs="$noconfigdirs ${libgcj}"
2422     ;;
2423   moxie-*-*)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     noconfigdirs="$noconfigdirs gprof"
2426     ;;
2427   h8300*-*-*)
2428     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2429     ;;
2430   h8500-*-*)
2431     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2432     ;;
2433   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2434     ;;
2435   hppa*64*-*-linux* | parisc*64*-*-linux*)
2436     # In this case, it's because the hppa64-linux target is for
2437     # the kernel only at this point and has no libc, and thus no
2438     # headers, crt*.o, etc., all of which are needed by these.
2439     noconfigdirs="$noconfigdirs target-zlib"
2440     ;;
2441   parisc*-*-linux* | hppa*-*-linux*)
2442     ;;
2443   hppa*-*-*elf* | \
2444   hppa*-*-lites* | \
2445   hppa*-*-openbsd* | \
2446   hppa*64*-*-*)
2447     noconfigdirs="$noconfigdirs ${libgcj}"
2448     ;;
2449   hppa*-hp-hpux11*)
2450     noconfigdirs="$noconfigdirs ld shellutils"
2451     ;;
2452   hppa*-*-pro*)
2453     libgloss_dir=pa
2454     ;;
2455   hppa*-*-*)
2456     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2457     # build on HP-UX 10.20.
2458     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2459     ;;
2460   i960-*-*)
2461     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2462     ;;
2463   ia64*-*-elf*)
2464     # No gdb support yet.
2465     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2466     ;;
2467   ia64*-**-hpux*)
2468     # No gdb or ld support yet.
2469     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2470     ;;
2471   ia64*-*-*vms*)
2472     # No gdb or ld support yet.
2473     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2474     ;;
2475   i370-*-opened*)
2476     ;;
2477   i[3456789]86-*-coff | i[3456789]86-*-elf)
2478     noconfigdirs="$noconfigdirs ${libgcj}"
2479     libgloss_dir=i386
2480     ;;
2481   i[3456789]86-*-linux*)
2482     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2483     # not build java stuff by default.
2484     case "${target}" in
2485       *-*-*libc1*)
2486         noconfigdirs="$noconfigdirs ${libgcj}";;
2487     esac
2488
2489     # This section makes it possible to build newlib natively on linux.
2490     # If we are using a cross compiler then don't configure newlib.
2491     if test x${is_cross_compiler} != xno ; then
2492       noconfigdirs="$noconfigdirs target-newlib"
2493     fi
2494     noconfigdirs="$noconfigdirs target-libgloss"
2495     # If we are not using a cross compiler, do configure newlib.
2496     # Note however, that newlib will only be configured in this situation
2497     # if the --with-newlib option has been given, because otherwise
2498     # 'target-newlib' will appear in skipdirs.
2499     ;;
2500   i[3456789]86-*-mingw32*)
2501     target_configdirs="$target_configdirs target-winsup"
2502     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2503     ;;
2504   x86_64-*-mingw*)
2505     target_configdirs="$target_configdirs target-winsup"
2506     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2507     ;;
2508   *-*-cygwin*)
2509     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2510     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2511     # always build newlib if winsup directory is present.
2512     if test -d "$srcdir/winsup/cygwin"; then
2513       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2514     elif test -d "$srcdir/newlib"; then
2515       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2516     fi
2517     ;;
2518   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2519   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2520     ;;
2521   i[3456789]86-*-pe)
2522     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2523     ;;
2524   i[3456789]86-*-sco3.2v5*)
2525     # The linker does not yet know about weak symbols in COFF,
2526     # and is not configured to handle mixed ELF and COFF.
2527     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2528     ;;
2529   i[3456789]86-*-sco*)
2530     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2531     ;;
2532   i[3456789]86-*-solaris2*)
2533     noconfigdirs="$noconfigdirs target-libgloss"
2534     ;;
2535   i[3456789]86-*-sysv4*)
2536     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2537     ;;
2538   i[3456789]86-*-beos*)
2539     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2540     ;;
2541   i[3456789]86-*-rdos*)
2542     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2543     ;;
2544   m32r-*-*)
2545     noconfigdirs="$noconfigdirs ${libgcj}"
2546     ;;
2547   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2548     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2549     libgloss_dir=m68hc11
2550     ;;
2551   m68k-*-elf*)
2552     noconfigdirs="$noconfigdirs ${libgcj}"
2553     ;;
2554   m68k-*-coff*)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     ;;
2557   m68*-*-* | fido-*-*)
2558     libgloss_dir=m68k
2559     ;;
2560   mcore-*-pe*)
2561   # The EPOC C++ environment does not support exceptions or rtti,
2562   # and so building libstdc++-v3 tends not to always work.
2563     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2564     ;;
2565   mmix-*-*)
2566     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2567     unsupported_languages="$unsupported_languages fortran java"
2568     ;;
2569   mn10200-*-*)
2570     noconfigdirs="$noconfigdirs ${libgcj}"
2571     ;;
2572   mn10300-*-*)
2573     noconfigdirs="$noconfigdirs ${libgcj}"
2574     ;;
2575   mt-*-*)
2576     noconfigdirs="$noconfigdirs sim"
2577     ;;
2578   powerpc-*-aix*)
2579     # copied from rs6000-*-* entry
2580     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2581     ;;
2582   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2583     target_configdirs="$target_configdirs target-winsup"
2584     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2585     # always build newlib.
2586     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2587     ;;
2588     # This is temporary until we can link against shared libraries
2589   powerpcle-*-solaris*)
2590     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2591     libgloss_dir=rs6000
2592     ;;
2593   powerpc-*-beos*)
2594     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2595     ;;
2596   powerpc-*-eabi)
2597     noconfigdirs="$noconfigdirs ${libgcj}"
2598     libgloss_dir=rs6000
2599     ;;
2600   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2601     libgloss_dir=rs6000
2602     ;;
2603   rs6000-*-lynxos*)
2604     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2605     ;;
2606   rs6000-*-aix*)
2607     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2608     ;;
2609   rs6000-*-*)
2610     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2611     ;;
2612   m68k-apollo-*)
2613     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2614     ;;
2615   mips*-sde-elf*)
2616     skipdirs="$skipdirs target-libiberty"
2617     noconfigdirs="$noconfigdirs ${libgcj}"
2618     if test x$with_newlib = xyes; then
2619       noconfigdirs="$noconfigdirs gprof"
2620     fi
2621     libgloss_dir=mips
2622     ;;
2623   mips*-*-irix5*)
2624     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2625     ;;
2626   mips*-*-irix6*)
2627     # Linking libjava exceeds command-line length limits on at least
2628     # IRIX 6.2, but not on IRIX 6.5.
2629     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2630     # <oldham@codesourcery.com>
2631     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2632     ;;
2633   mips*-*-bsd*)
2634     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2635     ;;
2636   mips*-*-linux*)
2637     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2638     ;;
2639   mips*-*-*)
2640     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2641     libgloss_dir=mips
2642     ;;
2643   romp-*-*)
2644     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2645     ;;
2646   sh-*-* | sh64-*-*)
2647     case "${host}" in
2648       i[3456789]86-*-vsta) ;; # don't add gprof back in
2649       i[3456789]86-*-go32*) ;; # don't add gprof back in
2650       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2651       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2652     esac
2653     case "${target}" in
2654       sh*-*-elf)
2655          noconfigdirs="$noconfigdirs ${libgcj}" ;;
2656       *)
2657          noconfigdirs="$noconfigdirs target-libgloss ${libgcj}" ;;
2658     esac
2659     ;;
2660   sparclet-*-aout* | sparc86x-*-*)
2661     libgloss_dir=sparc
2662     ;;
2663   sparc-*-elf*)
2664     noconfigdirs="$noconfigdirs ${libgcj}"
2665     ;;
2666   sparc64-*-elf*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     libgloss_dir=sparc
2669     ;;
2670   sparclite-*-*)
2671     noconfigdirs="$noconfigdirs ${libgcj}"
2672     libgloss_dir=sparc
2673     ;;
2674   sparc-*-sunos4*)
2675     noconfigdirs="$noconfigdirs ${libgcj}"
2676     if test x${is_cross_compiler} != xno ; then
2677            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2678     else
2679            use_gnu_ld=no
2680     fi
2681     ;;
2682   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2683     noconfigdirs="$noconfigdirs ${libgcj}"
2684     ;;
2685   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2686     ;;
2687   v810-*-*)
2688     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2689     ;;
2690   v850-*-*)
2691     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2692     ;;
2693   v850e-*-*)
2694     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2695     ;;
2696   v850ea-*-*)
2697     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2698     ;;
2699   vax-*-vms)
2700     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2701     ;;
2702   vax-*-*)
2703     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2704     ;;
2705   xtensa*-*-*)
2706     noconfigdirs="$noconfigdirs ${libgcj}"
2707     ;;
2708   ip2k-*-*)
2709     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2710     ;;
2711   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2712     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2713     ;;
2714   *-*-lynxos*)
2715     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2716     ;;
2717   *-*-*)
2718     noconfigdirs="$noconfigdirs ${libgcj}"
2719     ;;
2720 esac
2721
2722 # If we aren't building newlib, then don't build libgloss, since libgloss
2723 # depends upon some newlib header files.
2724 case "${noconfigdirs}" in
2725   *target-libgloss*) ;;
2726   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2727 esac
2728
2729 # Work in distributions that contain no compiler tools, like Autoconf.
2730 tentative_cc=""
2731 host_makefile_frag=/dev/null
2732 if test -d ${srcdir}/config ; then
2733 case "${host}" in
2734   m68k-hp-hpux*)
2735     # Avoid "too much defining" errors from HPUX compiler.
2736     tentative_cc="cc -Wp,-H256000"
2737     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2738     # If it's HP/UX ar, this should be harmless.
2739     RANLIB="ar ts"
2740     ;;
2741   m68k-apollo-sysv*)
2742     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2743     ;;
2744   m68k-apollo-bsd*)
2745     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2746     # chokes on bfd, the compiler won't let you assign integers to enums, and
2747     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2748     # the apollo compiler" (the preferred version of GCC could be called cc,
2749     # or whatever), but I'm not sure leaving CC as cc is any better...
2750     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2751     # Used to have BISON=yacc.
2752     tentative_cc=gcc
2753     ;;
2754   m88k-dg-dgux*)
2755     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2756     ;;
2757   m88k-harris-cxux*)
2758     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2759     tentative_cc="cc -Xa"
2760     host_makefile_frag="config/mh-cxux"
2761     ;;
2762   m88k-motorola-sysv*)
2763     ;;
2764   mips*-dec-ultrix*)
2765     tentative_cc="cc -Wf,-XNg1000"
2766     host_makefile_frag="config/mh-decstation"
2767     ;;
2768   mips*-nec-sysv4*)
2769     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2770     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2771     host_makefile_frag="config/mh-necv4"
2772     ;;
2773   mips*-sgi-irix4*)
2774     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2775     # environment.  Also bump switch table size so that cp-parse will
2776     # compile.  Bump string length limit so linker builds.
2777     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2778     ;;
2779   mips*-*-sysv4*)
2780     host_makefile_frag="config/mh-sysv4"
2781     ;;
2782   mips*-*-sysv*)
2783     # This is for a MIPS running RISC/os 4.52C.
2784
2785     # This is needed for GDB, but needs to be in the top-level make because
2786     # if a library is compiled with the bsd headers and gets linked with the
2787     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2788     # a different size).
2789     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2790     # known except to select the sysv environment.  Could we use /proc instead?
2791     # These "sysv environments" and "bsd environments" often end up being a pain.
2792     #
2793     # This is not part of CFLAGS because perhaps not all C compilers have this
2794     # option.
2795     tentative_cc="cc -systype sysv"
2796     ;;
2797   i370-ibm-opened*)
2798     tentative_cc="c89"
2799     ;;
2800   i[3456789]86-*-sysv5*)
2801     host_makefile_frag="config/mh-sysv5"
2802     ;;
2803   i[3456789]86-*-dgux*)
2804     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2805     host_makefile_frag="config/mh-dgux386"
2806     ;;
2807   i[3456789]86-ncr-sysv4.3*)
2808     # The MetaWare compiler will generate a copyright message unless you
2809     # turn it off by adding the -Hnocopyr flag.
2810     tentative_cc="cc -Hnocopyr"
2811     ;;
2812   i[3456789]86-ncr-sysv4*)
2813     # for an NCR 3000 (i486/SVR4) system.
2814     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2815     # This compiler not only emits obnoxious copyright messages every time
2816     # you run it, but it chokes and dies on a whole bunch of GNU source
2817     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2818     tentative_cc="/usr/ccs/ATT/cc"
2819     host_makefile_frag="config/mh-ncr3000"
2820     ;;
2821   i[3456789]86-*-sco3.2v5*)
2822     ;;
2823   i[3456789]86-*-sco*)
2824     # The native C compiler botches some simple uses of const.  Unfortunately,
2825     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2826     tentative_cc="cc -Dconst="
2827     host_makefile_frag="config/mh-sco"
2828     ;;
2829   i[3456789]86-*-udk*)
2830     host_makefile_frag="config/mh-sysv5"
2831     ;;
2832   i[3456789]86-*-solaris2*)
2833     host_makefile_frag="config/mh-sysv4"
2834     ;;
2835   i[3456789]86-*-msdosdjgpp*)
2836     host_makefile_frag="config/mh-djgpp"
2837     ;;
2838   *-cygwin*)
2839
2840 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2841 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2842 echo a >cygwin-cat-check
2843 if test `cat cygwin-cat-check` == a ; then
2844   rm cygwin-cat-check
2845   echo "$as_me:$LINENO: result: yes" >&5
2846 echo "${ECHO_T}yes" >&6
2847 else
2848   rm cygwin-cat-check
2849   echo "$as_me:$LINENO: result: no" >&5
2850 echo "${ECHO_T}no" >&6
2851   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2852   Please either mount the build directory in binary mode or run the following
2853   commands before running any configure script:
2854 set -o igncr
2855 export SHELLOPTS
2856   " >&5
2857 echo "$as_me: error: The cat command does not ignore carriage return characters.
2858   Please either mount the build directory in binary mode or run the following
2859   commands before running any configure script:
2860 set -o igncr
2861 export SHELLOPTS
2862   " >&2;}
2863    { (exit 1); exit 1; }; }
2864 fi
2865
2866     host_makefile_frag="config/mh-cygwin"
2867     ;;
2868   *-mingw*)
2869     host_makefile_frag="config/mh-mingw"
2870     ;;
2871   *-interix*)
2872     host_makefile_frag="config/mh-interix"
2873     ;;
2874   vax-*-ultrix2*)
2875     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2876     tentative_cc=gcc
2877     ;;
2878   *-*-solaris2*)
2879     host_makefile_frag="config/mh-solaris"
2880     ;;
2881   m68k-sun-sunos*)
2882     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2883     # without overflowing the jump tables (-J says to use a 32 bit table)
2884     tentative_cc="cc -J"
2885     ;;
2886   hppa*-hp-hpux10*)
2887     tentative_cc="cc -Wp,-H256000"
2888     host_makefile_frag="config/mh-pa-hpux10"
2889     ;;
2890   hppa*-hp-hpux* | hppa*-*-hiux*)
2891     tentative_cc="cc -Wp,-H256000"
2892     host_makefile_frag="config/mh-pa"
2893     ;;
2894   hppa*-*)
2895     host_makefile_frag="config/mh-pa"
2896     ;;
2897   *-hp-hpux* | *-*-hiux*)
2898     tentative_cc="cc -Wp,-H256000"
2899     ;;
2900   rs6000-*-lynxos*)
2901     # /bin/cc is less than useful for our purposes.  Always use GCC
2902     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2903     host_makefile_frag="config/mh-lynxrs6k"
2904     ;;
2905   powerpc-*-darwin*)
2906     host_makefile_frag="config/mh-ppc-darwin"
2907     ;;
2908   powerpc-*-aix*)
2909     host_makefile_frag="config/mh-ppc-aix"
2910     ;;
2911   rs6000-*-aix*)
2912     host_makefile_frag="config/mh-ppc-aix"
2913     ;;
2914   *-*-lynxos*)
2915     # /bin/cc is less than useful for our purposes.  Always use GCC
2916     tentative_cc="/bin/gcc"
2917     ;;
2918   *-*-sysv4*)
2919     host_makefile_frag="config/mh-sysv4"
2920     ;;
2921   # This is placed last to prevent interfering with the cases above.
2922   i[3456789]86-*-*)
2923     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2924     host_makefile_frag="config/mh-x86omitfp"
2925     ;;
2926 esac
2927 fi
2928
2929 # If we aren't going to be using gcc, see if we can extract a definition
2930 # of CC from the fragment.
2931 # Actually, use the 'pre-extracted' version above.
2932 if test -z "${CC}" && test "${build}" = "${host}" ; then
2933   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2934   found=
2935   for dir in $PATH; do
2936     test -z "$dir" && dir=.
2937     if test -f $dir/gcc; then
2938       found=yes
2939       break
2940     fi
2941   done
2942   IFS="$save_ifs"
2943   if test -z "${found}" && test -n "${tentative_cc}" ; then
2944     CC=$tentative_cc
2945   fi
2946 fi
2947
2948 if test "${build}" != "${host}" ; then
2949   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2950   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2951   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2952   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2953   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2954   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2955   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2956   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2957   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2958   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2959   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2960   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2961 else
2962   AR_FOR_BUILD="\$(AR)"
2963   AS_FOR_BUILD="\$(AS)"
2964   CC_FOR_BUILD="\$(CC)"
2965   CXX_FOR_BUILD="\$(CXX)"
2966   GCJ_FOR_BUILD="\$(GCJ)"
2967   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2968   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2969   LD_FOR_BUILD="\$(LD)"
2970   NM_FOR_BUILD="\$(NM)"
2971   RANLIB_FOR_BUILD="\$(RANLIB)"
2972   WINDRES_FOR_BUILD="\$(WINDRES)"
2973   WINDMC_FOR_BUILD="\$(WINDMC)"
2974 fi
2975
2976 ac_ext=c
2977 ac_cpp='$CPP $CPPFLAGS'
2978 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2979 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2980 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2981 if test -n "$ac_tool_prefix"; then
2982   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2983 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2984 echo "$as_me:$LINENO: checking for $ac_word" >&5
2985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2986 if test "${ac_cv_prog_CC+set}" = set; then
2987   echo $ECHO_N "(cached) $ECHO_C" >&6
2988 else
2989   if test -n "$CC"; then
2990   ac_cv_prog_CC="$CC" # Let the user override the test.
2991 else
2992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2993 for as_dir in $PATH
2994 do
2995   IFS=$as_save_IFS
2996   test -z "$as_dir" && as_dir=.
2997   for ac_exec_ext in '' $ac_executable_extensions; do
2998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2999     ac_cv_prog_CC="${ac_tool_prefix}gcc"
3000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3001     break 2
3002   fi
3003 done
3004 done
3005
3006 fi
3007 fi
3008 CC=$ac_cv_prog_CC
3009 if test -n "$CC"; then
3010   echo "$as_me:$LINENO: result: $CC" >&5
3011 echo "${ECHO_T}$CC" >&6
3012 else
3013   echo "$as_me:$LINENO: result: no" >&5
3014 echo "${ECHO_T}no" >&6
3015 fi
3016
3017 fi
3018 if test -z "$ac_cv_prog_CC"; then
3019   ac_ct_CC=$CC
3020   # Extract the first word of "gcc", so it can be a program name with args.
3021 set dummy gcc; ac_word=$2
3022 echo "$as_me:$LINENO: checking for $ac_word" >&5
3023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3024 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3025   echo $ECHO_N "(cached) $ECHO_C" >&6
3026 else
3027   if test -n "$ac_ct_CC"; then
3028   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3029 else
3030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3031 for as_dir in $PATH
3032 do
3033   IFS=$as_save_IFS
3034   test -z "$as_dir" && as_dir=.
3035   for ac_exec_ext in '' $ac_executable_extensions; do
3036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3037     ac_cv_prog_ac_ct_CC="gcc"
3038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3039     break 2
3040   fi
3041 done
3042 done
3043
3044 fi
3045 fi
3046 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3047 if test -n "$ac_ct_CC"; then
3048   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3049 echo "${ECHO_T}$ac_ct_CC" >&6
3050 else
3051   echo "$as_me:$LINENO: result: no" >&5
3052 echo "${ECHO_T}no" >&6
3053 fi
3054
3055   CC=$ac_ct_CC
3056 else
3057   CC="$ac_cv_prog_CC"
3058 fi
3059
3060 if test -z "$CC"; then
3061   if test -n "$ac_tool_prefix"; then
3062   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3063 set dummy ${ac_tool_prefix}cc; ac_word=$2
3064 echo "$as_me:$LINENO: checking for $ac_word" >&5
3065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3066 if test "${ac_cv_prog_CC+set}" = set; then
3067   echo $ECHO_N "(cached) $ECHO_C" >&6
3068 else
3069   if test -n "$CC"; then
3070   ac_cv_prog_CC="$CC" # Let the user override the test.
3071 else
3072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3073 for as_dir in $PATH
3074 do
3075   IFS=$as_save_IFS
3076   test -z "$as_dir" && as_dir=.
3077   for ac_exec_ext in '' $ac_executable_extensions; do
3078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3079     ac_cv_prog_CC="${ac_tool_prefix}cc"
3080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3081     break 2
3082   fi
3083 done
3084 done
3085
3086 fi
3087 fi
3088 CC=$ac_cv_prog_CC
3089 if test -n "$CC"; then
3090   echo "$as_me:$LINENO: result: $CC" >&5
3091 echo "${ECHO_T}$CC" >&6
3092 else
3093   echo "$as_me:$LINENO: result: no" >&5
3094 echo "${ECHO_T}no" >&6
3095 fi
3096
3097 fi
3098 if test -z "$ac_cv_prog_CC"; then
3099   ac_ct_CC=$CC
3100   # Extract the first word of "cc", so it can be a program name with args.
3101 set dummy cc; ac_word=$2
3102 echo "$as_me:$LINENO: checking for $ac_word" >&5
3103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3104 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3105   echo $ECHO_N "(cached) $ECHO_C" >&6
3106 else
3107   if test -n "$ac_ct_CC"; then
3108   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3109 else
3110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3111 for as_dir in $PATH
3112 do
3113   IFS=$as_save_IFS
3114   test -z "$as_dir" && as_dir=.
3115   for ac_exec_ext in '' $ac_executable_extensions; do
3116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3117     ac_cv_prog_ac_ct_CC="cc"
3118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3119     break 2
3120   fi
3121 done
3122 done
3123
3124 fi
3125 fi
3126 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3127 if test -n "$ac_ct_CC"; then
3128   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3129 echo "${ECHO_T}$ac_ct_CC" >&6
3130 else
3131   echo "$as_me:$LINENO: result: no" >&5
3132 echo "${ECHO_T}no" >&6
3133 fi
3134
3135   CC=$ac_ct_CC
3136 else
3137   CC="$ac_cv_prog_CC"
3138 fi
3139
3140 fi
3141 if test -z "$CC"; then
3142   # Extract the first word of "cc", so it can be a program name with args.
3143 set dummy cc; ac_word=$2
3144 echo "$as_me:$LINENO: checking for $ac_word" >&5
3145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3146 if test "${ac_cv_prog_CC+set}" = set; then
3147   echo $ECHO_N "(cached) $ECHO_C" >&6
3148 else
3149   if test -n "$CC"; then
3150   ac_cv_prog_CC="$CC" # Let the user override the test.
3151 else
3152   ac_prog_rejected=no
3153 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3154 for as_dir in $PATH
3155 do
3156   IFS=$as_save_IFS
3157   test -z "$as_dir" && as_dir=.
3158   for ac_exec_ext in '' $ac_executable_extensions; do
3159   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3160     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3161        ac_prog_rejected=yes
3162        continue
3163      fi
3164     ac_cv_prog_CC="cc"
3165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3166     break 2
3167   fi
3168 done
3169 done
3170
3171 if test $ac_prog_rejected = yes; then
3172   # We found a bogon in the path, so make sure we never use it.
3173   set dummy $ac_cv_prog_CC
3174   shift
3175   if test $# != 0; then
3176     # We chose a different compiler from the bogus one.
3177     # However, it has the same basename, so the bogon will be chosen
3178     # first if we set CC to just the basename; use the full file name.
3179     shift
3180     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3181   fi
3182 fi
3183 fi
3184 fi
3185 CC=$ac_cv_prog_CC
3186 if test -n "$CC"; then
3187   echo "$as_me:$LINENO: result: $CC" >&5
3188 echo "${ECHO_T}$CC" >&6
3189 else
3190   echo "$as_me:$LINENO: result: no" >&5
3191 echo "${ECHO_T}no" >&6
3192 fi
3193
3194 fi
3195 if test -z "$CC"; then
3196   if test -n "$ac_tool_prefix"; then
3197   for ac_prog in cl
3198   do
3199     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3200 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3201 echo "$as_me:$LINENO: checking for $ac_word" >&5
3202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3203 if test "${ac_cv_prog_CC+set}" = set; then
3204   echo $ECHO_N "(cached) $ECHO_C" >&6
3205 else
3206   if test -n "$CC"; then
3207   ac_cv_prog_CC="$CC" # Let the user override the test.
3208 else
3209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3210 for as_dir in $PATH
3211 do
3212   IFS=$as_save_IFS
3213   test -z "$as_dir" && as_dir=.
3214   for ac_exec_ext in '' $ac_executable_extensions; do
3215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3216     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3218     break 2
3219   fi
3220 done
3221 done
3222
3223 fi
3224 fi
3225 CC=$ac_cv_prog_CC
3226 if test -n "$CC"; then
3227   echo "$as_me:$LINENO: result: $CC" >&5
3228 echo "${ECHO_T}$CC" >&6
3229 else
3230   echo "$as_me:$LINENO: result: no" >&5
3231 echo "${ECHO_T}no" >&6
3232 fi
3233
3234     test -n "$CC" && break
3235   done
3236 fi
3237 if test -z "$CC"; then
3238   ac_ct_CC=$CC
3239   for ac_prog in cl
3240 do
3241   # Extract the first word of "$ac_prog", so it can be a program name with args.
3242 set dummy $ac_prog; ac_word=$2
3243 echo "$as_me:$LINENO: checking for $ac_word" >&5
3244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3245 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3246   echo $ECHO_N "(cached) $ECHO_C" >&6
3247 else
3248   if test -n "$ac_ct_CC"; then
3249   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3250 else
3251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3252 for as_dir in $PATH
3253 do
3254   IFS=$as_save_IFS
3255   test -z "$as_dir" && as_dir=.
3256   for ac_exec_ext in '' $ac_executable_extensions; do
3257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3258     ac_cv_prog_ac_ct_CC="$ac_prog"
3259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3260     break 2
3261   fi
3262 done
3263 done
3264
3265 fi
3266 fi
3267 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3268 if test -n "$ac_ct_CC"; then
3269   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3270 echo "${ECHO_T}$ac_ct_CC" >&6
3271 else
3272   echo "$as_me:$LINENO: result: no" >&5
3273 echo "${ECHO_T}no" >&6
3274 fi
3275
3276   test -n "$ac_ct_CC" && break
3277 done
3278
3279   CC=$ac_ct_CC
3280 fi
3281
3282 fi
3283
3284
3285 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3286 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3287 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3288 See \`config.log' for more details." >&5
3289 echo "$as_me: error: no acceptable C compiler found in \$PATH
3290 See \`config.log' for more details." >&2;}
3291    { (exit 1); exit 1; }; }; }
3292
3293 # Provide some information about the compiler.
3294 echo "$as_me:$LINENO:" \
3295      "checking for C compiler version" >&5
3296 ac_compiler=`set X $ac_compile; echo $2`
3297 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3298   (eval $ac_compiler --version </dev/null >&5) 2>&5
3299   ac_status=$?
3300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3301   (exit $ac_status); }
3302 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3303   (eval $ac_compiler -v </dev/null >&5) 2>&5
3304   ac_status=$?
3305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3306   (exit $ac_status); }
3307 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3308   (eval $ac_compiler -V </dev/null >&5) 2>&5
3309   ac_status=$?
3310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3311   (exit $ac_status); }
3312
3313 cat >conftest.$ac_ext <<_ACEOF
3314 /* confdefs.h.  */
3315 _ACEOF
3316 cat confdefs.h >>conftest.$ac_ext
3317 cat >>conftest.$ac_ext <<_ACEOF
3318 /* end confdefs.h.  */
3319
3320 int
3321 main ()
3322 {
3323
3324   ;
3325   return 0;
3326 }
3327 _ACEOF
3328 ac_clean_files_save=$ac_clean_files
3329 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3330 # Try to create an executable without -o first, disregard a.out.
3331 # It will help us diagnose broken compilers, and finding out an intuition
3332 # of exeext.
3333 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3334 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3335 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3336 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3337   (eval $ac_link_default) 2>&5
3338   ac_status=$?
3339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3340   (exit $ac_status); }; then
3341   # Find the output, starting from the most likely.  This scheme is
3342 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3343 # resort.
3344
3345 # Be careful to initialize this variable, since it used to be cached.
3346 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3347 ac_cv_exeext=
3348 # b.out is created by i960 compilers.
3349 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3350 do
3351   test -f "$ac_file" || continue
3352   case $ac_file in
3353     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3354         ;;
3355     conftest.$ac_ext )
3356         # This is the source file.
3357         ;;
3358     [ab].out )
3359         # We found the default executable, but exeext='' is most
3360         # certainly right.
3361         break;;
3362     *.* )
3363         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3364         # FIXME: I believe we export ac_cv_exeext for Libtool,
3365         # but it would be cool to find out if it's true.  Does anybody
3366         # maintain Libtool? --akim.
3367         export ac_cv_exeext
3368         break;;
3369     * )
3370         break;;
3371   esac
3372 done
3373 else
3374   echo "$as_me: failed program was:" >&5
3375 sed 's/^/| /' conftest.$ac_ext >&5
3376
3377 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3378 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3379 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3380 See \`config.log' for more details." >&5
3381 echo "$as_me: error: C compiler cannot create executables
3382 See \`config.log' for more details." >&2;}
3383    { (exit 77); exit 77; }; }; }
3384 fi
3385
3386 ac_exeext=$ac_cv_exeext
3387 echo "$as_me:$LINENO: result: $ac_file" >&5
3388 echo "${ECHO_T}$ac_file" >&6
3389
3390 # Check the compiler produces executables we can run.  If not, either
3391 # the compiler is broken, or we cross compile.
3392 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3393 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3394 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3395 # If not cross compiling, check that we can run a simple program.
3396 if test "$cross_compiling" != yes; then
3397   if { ac_try='./$ac_file'
3398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3399   (eval $ac_try) 2>&5
3400   ac_status=$?
3401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3402   (exit $ac_status); }; }; then
3403     cross_compiling=no
3404   else
3405     if test "$cross_compiling" = maybe; then
3406         cross_compiling=yes
3407     else
3408         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3409 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3410 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3411 If you meant to cross compile, use \`--host'.
3412 See \`config.log' for more details." >&5
3413 echo "$as_me: error: cannot run C compiled programs.
3414 If you meant to cross compile, use \`--host'.
3415 See \`config.log' for more details." >&2;}
3416    { (exit 1); exit 1; }; }; }
3417     fi
3418   fi
3419 fi
3420 echo "$as_me:$LINENO: result: yes" >&5
3421 echo "${ECHO_T}yes" >&6
3422
3423 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3424 ac_clean_files=$ac_clean_files_save
3425 # Check the compiler produces executables we can run.  If not, either
3426 # the compiler is broken, or we cross compile.
3427 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3428 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3429 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3430 echo "${ECHO_T}$cross_compiling" >&6
3431
3432 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3433 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3434 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3435   (eval $ac_link) 2>&5
3436   ac_status=$?
3437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3438   (exit $ac_status); }; then
3439   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3440 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3441 # work properly (i.e., refer to `conftest.exe'), while it won't with
3442 # `rm'.
3443 for ac_file in conftest.exe conftest conftest.*; do
3444   test -f "$ac_file" || continue
3445   case $ac_file in
3446     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3447     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3448           export ac_cv_exeext
3449           break;;
3450     * ) break;;
3451   esac
3452 done
3453 else
3454   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3455 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3456 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3457 See \`config.log' for more details." >&5
3458 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3459 See \`config.log' for more details." >&2;}
3460    { (exit 1); exit 1; }; }; }
3461 fi
3462
3463 rm -f conftest$ac_cv_exeext
3464 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3465 echo "${ECHO_T}$ac_cv_exeext" >&6
3466
3467 rm -f conftest.$ac_ext
3468 EXEEXT=$ac_cv_exeext
3469 ac_exeext=$EXEEXT
3470 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3471 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3472 if test "${ac_cv_objext+set}" = set; then
3473   echo $ECHO_N "(cached) $ECHO_C" >&6
3474 else
3475   cat >conftest.$ac_ext <<_ACEOF
3476 /* confdefs.h.  */
3477 _ACEOF
3478 cat confdefs.h >>conftest.$ac_ext
3479 cat >>conftest.$ac_ext <<_ACEOF
3480 /* end confdefs.h.  */
3481
3482 int
3483 main ()
3484 {
3485
3486   ;
3487   return 0;
3488 }
3489 _ACEOF
3490 rm -f conftest.o conftest.obj
3491 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3492   (eval $ac_compile) 2>&5
3493   ac_status=$?
3494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3495   (exit $ac_status); }; then
3496   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3497   case $ac_file in
3498     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3499     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3500        break;;
3501   esac
3502 done
3503 else
3504   echo "$as_me: failed program was:" >&5
3505 sed 's/^/| /' conftest.$ac_ext >&5
3506
3507 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3508 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3509 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3510 See \`config.log' for more details." >&5
3511 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3512 See \`config.log' for more details." >&2;}
3513    { (exit 1); exit 1; }; }; }
3514 fi
3515
3516 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3517 fi
3518 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3519 echo "${ECHO_T}$ac_cv_objext" >&6
3520 OBJEXT=$ac_cv_objext
3521 ac_objext=$OBJEXT
3522 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3523 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3524 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3525   echo $ECHO_N "(cached) $ECHO_C" >&6
3526 else
3527   cat >conftest.$ac_ext <<_ACEOF
3528 /* confdefs.h.  */
3529 _ACEOF
3530 cat confdefs.h >>conftest.$ac_ext
3531 cat >>conftest.$ac_ext <<_ACEOF
3532 /* end confdefs.h.  */
3533
3534 int
3535 main ()
3536 {
3537 #ifndef __GNUC__
3538        choke me
3539 #endif
3540
3541   ;
3542   return 0;
3543 }
3544 _ACEOF
3545 rm -f conftest.$ac_objext
3546 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3547   (eval $ac_compile) 2>conftest.er1
3548   ac_status=$?
3549   grep -v '^ *+' conftest.er1 >conftest.err
3550   rm -f conftest.er1
3551   cat conftest.err >&5
3552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3553   (exit $ac_status); } &&
3554          { ac_try='test -z "$ac_c_werror_flag"
3555                          || test ! -s conftest.err'
3556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3557   (eval $ac_try) 2>&5
3558   ac_status=$?
3559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3560   (exit $ac_status); }; } &&
3561          { ac_try='test -s conftest.$ac_objext'
3562   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3563   (eval $ac_try) 2>&5
3564   ac_status=$?
3565   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3566   (exit $ac_status); }; }; then
3567   ac_compiler_gnu=yes
3568 else
3569   echo "$as_me: failed program was:" >&5
3570 sed 's/^/| /' conftest.$ac_ext >&5
3571
3572 ac_compiler_gnu=no
3573 fi
3574 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3575 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3576
3577 fi
3578 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3579 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3580 GCC=`test $ac_compiler_gnu = yes && echo yes`
3581 ac_test_CFLAGS=${CFLAGS+set}
3582 ac_save_CFLAGS=$CFLAGS
3583 CFLAGS="-g"
3584 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3585 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3586 if test "${ac_cv_prog_cc_g+set}" = set; then
3587   echo $ECHO_N "(cached) $ECHO_C" >&6
3588 else
3589   cat >conftest.$ac_ext <<_ACEOF
3590 /* confdefs.h.  */
3591 _ACEOF
3592 cat confdefs.h >>conftest.$ac_ext
3593 cat >>conftest.$ac_ext <<_ACEOF
3594 /* end confdefs.h.  */
3595
3596 int
3597 main ()
3598 {
3599
3600   ;
3601   return 0;
3602 }
3603 _ACEOF
3604 rm -f conftest.$ac_objext
3605 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3606   (eval $ac_compile) 2>conftest.er1
3607   ac_status=$?
3608   grep -v '^ *+' conftest.er1 >conftest.err
3609   rm -f conftest.er1
3610   cat conftest.err >&5
3611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3612   (exit $ac_status); } &&
3613          { ac_try='test -z "$ac_c_werror_flag"
3614                          || test ! -s conftest.err'
3615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3616   (eval $ac_try) 2>&5
3617   ac_status=$?
3618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3619   (exit $ac_status); }; } &&
3620          { ac_try='test -s conftest.$ac_objext'
3621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3622   (eval $ac_try) 2>&5
3623   ac_status=$?
3624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3625   (exit $ac_status); }; }; then
3626   ac_cv_prog_cc_g=yes
3627 else
3628   echo "$as_me: failed program was:" >&5
3629 sed 's/^/| /' conftest.$ac_ext >&5
3630
3631 ac_cv_prog_cc_g=no
3632 fi
3633 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3634 fi
3635 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3636 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3637 if test "$ac_test_CFLAGS" = set; then
3638   CFLAGS=$ac_save_CFLAGS
3639 elif test $ac_cv_prog_cc_g = yes; then
3640   if test "$GCC" = yes; then
3641     CFLAGS="-g -O2"
3642   else
3643     CFLAGS="-g"
3644   fi
3645 else
3646   if test "$GCC" = yes; then
3647     CFLAGS="-O2"
3648   else
3649     CFLAGS=
3650   fi
3651 fi
3652 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3653 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3654 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3655   echo $ECHO_N "(cached) $ECHO_C" >&6
3656 else
3657   ac_cv_prog_cc_stdc=no
3658 ac_save_CC=$CC
3659 cat >conftest.$ac_ext <<_ACEOF
3660 /* confdefs.h.  */
3661 _ACEOF
3662 cat confdefs.h >>conftest.$ac_ext
3663 cat >>conftest.$ac_ext <<_ACEOF
3664 /* end confdefs.h.  */
3665 #include <stdarg.h>
3666 #include <stdio.h>
3667 #include <sys/types.h>
3668 #include <sys/stat.h>
3669 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3670 struct buf { int x; };
3671 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3672 static char *e (p, i)
3673      char **p;
3674      int i;
3675 {
3676   return p[i];
3677 }
3678 static char *f (char * (*g) (char **, int), char **p, ...)
3679 {
3680   char *s;
3681   va_list v;
3682   va_start (v,p);
3683   s = g (p, va_arg (v,int));
3684   va_end (v);
3685   return s;
3686 }
3687
3688 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3689    function prototypes and stuff, but not '\xHH' hex character constants.
3690    These don't provoke an error unfortunately, instead are silently treated
3691    as 'x'.  The following induces an error, until -std1 is added to get
3692    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3693    array size at least.  It's necessary to write '\x00'==0 to get something
3694    that's true only with -std1.  */
3695 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3696
3697 int test (int i, double x);
3698 struct s1 {int (*f) (int a);};
3699 struct s2 {int (*f) (double a);};
3700 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3701 int argc;
3702 char **argv;
3703 int
3704 main ()
3705 {
3706 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3707   ;
3708   return 0;
3709 }
3710 _ACEOF
3711 # Don't try gcc -ansi; that turns off useful extensions and
3712 # breaks some systems' header files.
3713 # AIX                   -qlanglvl=ansi
3714 # Ultrix and OSF/1      -std1
3715 # HP-UX 10.20 and later -Ae
3716 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3717 # SVR4                  -Xc -D__EXTENSIONS__
3718 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3719 do
3720   CC="$ac_save_CC $ac_arg"
3721   rm -f conftest.$ac_objext
3722 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3723   (eval $ac_compile) 2>conftest.er1
3724   ac_status=$?
3725   grep -v '^ *+' conftest.er1 >conftest.err
3726   rm -f conftest.er1
3727   cat conftest.err >&5
3728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3729   (exit $ac_status); } &&
3730          { ac_try='test -z "$ac_c_werror_flag"
3731                          || test ! -s conftest.err'
3732   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3733   (eval $ac_try) 2>&5
3734   ac_status=$?
3735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3736   (exit $ac_status); }; } &&
3737          { ac_try='test -s conftest.$ac_objext'
3738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3739   (eval $ac_try) 2>&5
3740   ac_status=$?
3741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3742   (exit $ac_status); }; }; then
3743   ac_cv_prog_cc_stdc=$ac_arg
3744 break
3745 else
3746   echo "$as_me: failed program was:" >&5
3747 sed 's/^/| /' conftest.$ac_ext >&5
3748
3749 fi
3750 rm -f conftest.err conftest.$ac_objext
3751 done
3752 rm -f conftest.$ac_ext conftest.$ac_objext
3753 CC=$ac_save_CC
3754
3755 fi
3756
3757 case "x$ac_cv_prog_cc_stdc" in
3758   x|xno)
3759     echo "$as_me:$LINENO: result: none needed" >&5
3760 echo "${ECHO_T}none needed" >&6 ;;
3761   *)
3762     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3763 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3764     CC="$CC $ac_cv_prog_cc_stdc" ;;
3765 esac
3766
3767 # Some people use a C++ compiler to compile C.  Since we use `exit',
3768 # in C++ we need to declare it.  In case someone uses the same compiler
3769 # for both compiling C and C++ we need to have the C++ compiler decide
3770 # the declaration of exit, since it's the most demanding environment.
3771 cat >conftest.$ac_ext <<_ACEOF
3772 #ifndef __cplusplus
3773   choke me
3774 #endif
3775 _ACEOF
3776 rm -f conftest.$ac_objext
3777 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3778   (eval $ac_compile) 2>conftest.er1
3779   ac_status=$?
3780   grep -v '^ *+' conftest.er1 >conftest.err
3781   rm -f conftest.er1
3782   cat conftest.err >&5
3783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3784   (exit $ac_status); } &&
3785          { ac_try='test -z "$ac_c_werror_flag"
3786                          || test ! -s conftest.err'
3787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3788   (eval $ac_try) 2>&5
3789   ac_status=$?
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); }; } &&
3792          { ac_try='test -s conftest.$ac_objext'
3793   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3794   (eval $ac_try) 2>&5
3795   ac_status=$?
3796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3797   (exit $ac_status); }; }; then
3798   for ac_declaration in \
3799    '' \
3800    'extern "C" void std::exit (int) throw (); using std::exit;' \
3801    'extern "C" void std::exit (int); using std::exit;' \
3802    'extern "C" void exit (int) throw ();' \
3803    'extern "C" void exit (int);' \
3804    'void exit (int);'
3805 do
3806   cat >conftest.$ac_ext <<_ACEOF
3807 /* confdefs.h.  */
3808 _ACEOF
3809 cat confdefs.h >>conftest.$ac_ext
3810 cat >>conftest.$ac_ext <<_ACEOF
3811 /* end confdefs.h.  */
3812 $ac_declaration
3813 #include <stdlib.h>
3814 int
3815 main ()
3816 {
3817 exit (42);
3818   ;
3819   return 0;
3820 }
3821 _ACEOF
3822 rm -f conftest.$ac_objext
3823 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3824   (eval $ac_compile) 2>conftest.er1
3825   ac_status=$?
3826   grep -v '^ *+' conftest.er1 >conftest.err
3827   rm -f conftest.er1
3828   cat conftest.err >&5
3829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3830   (exit $ac_status); } &&
3831          { ac_try='test -z "$ac_c_werror_flag"
3832                          || test ! -s conftest.err'
3833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3834   (eval $ac_try) 2>&5
3835   ac_status=$?
3836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3837   (exit $ac_status); }; } &&
3838          { ac_try='test -s conftest.$ac_objext'
3839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3840   (eval $ac_try) 2>&5
3841   ac_status=$?
3842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3843   (exit $ac_status); }; }; then
3844   :
3845 else
3846   echo "$as_me: failed program was:" >&5
3847 sed 's/^/| /' conftest.$ac_ext >&5
3848
3849 continue
3850 fi
3851 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3852   cat >conftest.$ac_ext <<_ACEOF
3853 /* confdefs.h.  */
3854 _ACEOF
3855 cat confdefs.h >>conftest.$ac_ext
3856 cat >>conftest.$ac_ext <<_ACEOF
3857 /* end confdefs.h.  */
3858 $ac_declaration
3859 int
3860 main ()
3861 {
3862 exit (42);
3863   ;
3864   return 0;
3865 }
3866 _ACEOF
3867 rm -f conftest.$ac_objext
3868 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3869   (eval $ac_compile) 2>conftest.er1
3870   ac_status=$?
3871   grep -v '^ *+' conftest.er1 >conftest.err
3872   rm -f conftest.er1
3873   cat conftest.err >&5
3874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3875   (exit $ac_status); } &&
3876          { ac_try='test -z "$ac_c_werror_flag"
3877                          || test ! -s conftest.err'
3878   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3879   (eval $ac_try) 2>&5
3880   ac_status=$?
3881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3882   (exit $ac_status); }; } &&
3883          { ac_try='test -s conftest.$ac_objext'
3884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3885   (eval $ac_try) 2>&5
3886   ac_status=$?
3887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3888   (exit $ac_status); }; }; then
3889   break
3890 else
3891   echo "$as_me: failed program was:" >&5
3892 sed 's/^/| /' conftest.$ac_ext >&5
3893
3894 fi
3895 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3896 done
3897 rm -f conftest*
3898 if test -n "$ac_declaration"; then
3899   echo '#ifdef __cplusplus' >>confdefs.h
3900   echo $ac_declaration      >>confdefs.h
3901   echo '#endif'             >>confdefs.h
3902 fi
3903
3904 else
3905   echo "$as_me: failed program was:" >&5
3906 sed 's/^/| /' conftest.$ac_ext >&5
3907
3908 fi
3909 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3910 ac_ext=c
3911 ac_cpp='$CPP $CPPFLAGS'
3912 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3913 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3914 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3915
3916 ac_ext=cc
3917 ac_cpp='$CXXCPP $CPPFLAGS'
3918 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3919 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3920 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3921 if test -n "$ac_tool_prefix"; then
3922   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3923   do
3924     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3925 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3926 echo "$as_me:$LINENO: checking for $ac_word" >&5
3927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3928 if test "${ac_cv_prog_CXX+set}" = set; then
3929   echo $ECHO_N "(cached) $ECHO_C" >&6
3930 else
3931   if test -n "$CXX"; then
3932   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3933 else
3934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3935 for as_dir in $PATH
3936 do
3937   IFS=$as_save_IFS
3938   test -z "$as_dir" && as_dir=.
3939   for ac_exec_ext in '' $ac_executable_extensions; do
3940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3941     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3943     break 2
3944   fi
3945 done
3946 done
3947
3948 fi
3949 fi
3950 CXX=$ac_cv_prog_CXX
3951 if test -n "$CXX"; then
3952   echo "$as_me:$LINENO: result: $CXX" >&5
3953 echo "${ECHO_T}$CXX" >&6
3954 else
3955   echo "$as_me:$LINENO: result: no" >&5
3956 echo "${ECHO_T}no" >&6
3957 fi
3958
3959     test -n "$CXX" && break
3960   done
3961 fi
3962 if test -z "$CXX"; then
3963   ac_ct_CXX=$CXX
3964   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3965 do
3966   # Extract the first word of "$ac_prog", so it can be a program name with args.
3967 set dummy $ac_prog; ac_word=$2
3968 echo "$as_me:$LINENO: checking for $ac_word" >&5
3969 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3970 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3971   echo $ECHO_N "(cached) $ECHO_C" >&6
3972 else
3973   if test -n "$ac_ct_CXX"; then
3974   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3975 else
3976 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3977 for as_dir in $PATH
3978 do
3979   IFS=$as_save_IFS
3980   test -z "$as_dir" && as_dir=.
3981   for ac_exec_ext in '' $ac_executable_extensions; do
3982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3983     ac_cv_prog_ac_ct_CXX="$ac_prog"
3984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3985     break 2
3986   fi
3987 done
3988 done
3989
3990 fi
3991 fi
3992 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3993 if test -n "$ac_ct_CXX"; then
3994   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3995 echo "${ECHO_T}$ac_ct_CXX" >&6
3996 else
3997   echo "$as_me:$LINENO: result: no" >&5
3998 echo "${ECHO_T}no" >&6
3999 fi
4000
4001   test -n "$ac_ct_CXX" && break
4002 done
4003 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
4004
4005   CXX=$ac_ct_CXX
4006 fi
4007
4008
4009 # Provide some information about the compiler.
4010 echo "$as_me:$LINENO:" \
4011      "checking for C++ compiler version" >&5
4012 ac_compiler=`set X $ac_compile; echo $2`
4013 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4014   (eval $ac_compiler --version </dev/null >&5) 2>&5
4015   ac_status=$?
4016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4017   (exit $ac_status); }
4018 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4019   (eval $ac_compiler -v </dev/null >&5) 2>&5
4020   ac_status=$?
4021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4022   (exit $ac_status); }
4023 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4024   (eval $ac_compiler -V </dev/null >&5) 2>&5
4025   ac_status=$?
4026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4027   (exit $ac_status); }
4028
4029 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4030 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4031 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4032   echo $ECHO_N "(cached) $ECHO_C" >&6
4033 else
4034   cat >conftest.$ac_ext <<_ACEOF
4035 /* confdefs.h.  */
4036 _ACEOF
4037 cat confdefs.h >>conftest.$ac_ext
4038 cat >>conftest.$ac_ext <<_ACEOF
4039 /* end confdefs.h.  */
4040
4041 int
4042 main ()
4043 {
4044 #ifndef __GNUC__
4045        choke me
4046 #endif
4047
4048   ;
4049   return 0;
4050 }
4051 _ACEOF
4052 rm -f conftest.$ac_objext
4053 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4054   (eval $ac_compile) 2>conftest.er1
4055   ac_status=$?
4056   grep -v '^ *+' conftest.er1 >conftest.err
4057   rm -f conftest.er1
4058   cat conftest.err >&5
4059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4060   (exit $ac_status); } &&
4061          { ac_try='test -z "$ac_cxx_werror_flag"
4062                          || test ! -s conftest.err'
4063   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4064   (eval $ac_try) 2>&5
4065   ac_status=$?
4066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4067   (exit $ac_status); }; } &&
4068          { ac_try='test -s conftest.$ac_objext'
4069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4070   (eval $ac_try) 2>&5
4071   ac_status=$?
4072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4073   (exit $ac_status); }; }; then
4074   ac_compiler_gnu=yes
4075 else
4076   echo "$as_me: failed program was:" >&5
4077 sed 's/^/| /' conftest.$ac_ext >&5
4078
4079 ac_compiler_gnu=no
4080 fi
4081 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4082 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4083
4084 fi
4085 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4086 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4087 GXX=`test $ac_compiler_gnu = yes && echo yes`
4088 ac_test_CXXFLAGS=${CXXFLAGS+set}
4089 ac_save_CXXFLAGS=$CXXFLAGS
4090 CXXFLAGS="-g"
4091 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4092 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4093 if test "${ac_cv_prog_cxx_g+set}" = set; then
4094   echo $ECHO_N "(cached) $ECHO_C" >&6
4095 else
4096   cat >conftest.$ac_ext <<_ACEOF
4097 /* confdefs.h.  */
4098 _ACEOF
4099 cat confdefs.h >>conftest.$ac_ext
4100 cat >>conftest.$ac_ext <<_ACEOF
4101 /* end confdefs.h.  */
4102
4103 int
4104 main ()
4105 {
4106
4107   ;
4108   return 0;
4109 }
4110 _ACEOF
4111 rm -f conftest.$ac_objext
4112 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4113   (eval $ac_compile) 2>conftest.er1
4114   ac_status=$?
4115   grep -v '^ *+' conftest.er1 >conftest.err
4116   rm -f conftest.er1
4117   cat conftest.err >&5
4118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4119   (exit $ac_status); } &&
4120          { ac_try='test -z "$ac_cxx_werror_flag"
4121                          || test ! -s conftest.err'
4122   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4123   (eval $ac_try) 2>&5
4124   ac_status=$?
4125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4126   (exit $ac_status); }; } &&
4127          { ac_try='test -s conftest.$ac_objext'
4128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4129   (eval $ac_try) 2>&5
4130   ac_status=$?
4131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4132   (exit $ac_status); }; }; then
4133   ac_cv_prog_cxx_g=yes
4134 else
4135   echo "$as_me: failed program was:" >&5
4136 sed 's/^/| /' conftest.$ac_ext >&5
4137
4138 ac_cv_prog_cxx_g=no
4139 fi
4140 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4141 fi
4142 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4143 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4144 if test "$ac_test_CXXFLAGS" = set; then
4145   CXXFLAGS=$ac_save_CXXFLAGS
4146 elif test $ac_cv_prog_cxx_g = yes; then
4147   if test "$GXX" = yes; then
4148     CXXFLAGS="-g -O2"
4149   else
4150     CXXFLAGS="-g"
4151   fi
4152 else
4153   if test "$GXX" = yes; then
4154     CXXFLAGS="-O2"
4155   else
4156     CXXFLAGS=
4157   fi
4158 fi
4159 for ac_declaration in \
4160    '' \
4161    'extern "C" void std::exit (int) throw (); using std::exit;' \
4162    'extern "C" void std::exit (int); using std::exit;' \
4163    'extern "C" void exit (int) throw ();' \
4164    'extern "C" void exit (int);' \
4165    'void exit (int);'
4166 do
4167   cat >conftest.$ac_ext <<_ACEOF
4168 /* confdefs.h.  */
4169 _ACEOF
4170 cat confdefs.h >>conftest.$ac_ext
4171 cat >>conftest.$ac_ext <<_ACEOF
4172 /* end confdefs.h.  */
4173 $ac_declaration
4174 #include <stdlib.h>
4175 int
4176 main ()
4177 {
4178 exit (42);
4179   ;
4180   return 0;
4181 }
4182 _ACEOF
4183 rm -f conftest.$ac_objext
4184 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4185   (eval $ac_compile) 2>conftest.er1
4186   ac_status=$?
4187   grep -v '^ *+' conftest.er1 >conftest.err
4188   rm -f conftest.er1
4189   cat conftest.err >&5
4190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4191   (exit $ac_status); } &&
4192          { ac_try='test -z "$ac_cxx_werror_flag"
4193                          || test ! -s conftest.err'
4194   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4195   (eval $ac_try) 2>&5
4196   ac_status=$?
4197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4198   (exit $ac_status); }; } &&
4199          { ac_try='test -s conftest.$ac_objext'
4200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4201   (eval $ac_try) 2>&5
4202   ac_status=$?
4203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4204   (exit $ac_status); }; }; then
4205   :
4206 else
4207   echo "$as_me: failed program was:" >&5
4208 sed 's/^/| /' conftest.$ac_ext >&5
4209
4210 continue
4211 fi
4212 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4213   cat >conftest.$ac_ext <<_ACEOF
4214 /* confdefs.h.  */
4215 _ACEOF
4216 cat confdefs.h >>conftest.$ac_ext
4217 cat >>conftest.$ac_ext <<_ACEOF
4218 /* end confdefs.h.  */
4219 $ac_declaration
4220 int
4221 main ()
4222 {
4223 exit (42);
4224   ;
4225   return 0;
4226 }
4227 _ACEOF
4228 rm -f conftest.$ac_objext
4229 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4230   (eval $ac_compile) 2>conftest.er1
4231   ac_status=$?
4232   grep -v '^ *+' conftest.er1 >conftest.err
4233   rm -f conftest.er1
4234   cat conftest.err >&5
4235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4236   (exit $ac_status); } &&
4237          { ac_try='test -z "$ac_cxx_werror_flag"
4238                          || test ! -s conftest.err'
4239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4240   (eval $ac_try) 2>&5
4241   ac_status=$?
4242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4243   (exit $ac_status); }; } &&
4244          { ac_try='test -s conftest.$ac_objext'
4245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4246   (eval $ac_try) 2>&5
4247   ac_status=$?
4248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4249   (exit $ac_status); }; }; then
4250   break
4251 else
4252   echo "$as_me: failed program was:" >&5
4253 sed 's/^/| /' conftest.$ac_ext >&5
4254
4255 fi
4256 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4257 done
4258 rm -f conftest*
4259 if test -n "$ac_declaration"; then
4260   echo '#ifdef __cplusplus' >>confdefs.h
4261   echo $ac_declaration      >>confdefs.h
4262   echo '#endif'             >>confdefs.h
4263 fi
4264
4265 ac_ext=c
4266 ac_cpp='$CPP $CPPFLAGS'
4267 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4268 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4269 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4270
4271
4272 # We must set the default linker to the linker used by gcc for the correct
4273 # operation of libtool.  If LD is not defined and we are using gcc, try to
4274 # set the LD default to the ld used by gcc.
4275 if test -z "$LD"; then
4276   if test "$GCC" = yes; then
4277     case $build in
4278     *-*-mingw*)
4279       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4280     *)
4281       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4282     esac
4283     case $gcc_prog_ld in
4284     # Accept absolute paths.
4285     [\\/]* | [A-Za-z]:[\\/]*)
4286       LD="$gcc_prog_ld" ;;
4287     esac
4288   fi
4289 fi
4290
4291
4292
4293
4294 if test -n "$ac_tool_prefix"; then
4295   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4296 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4297 echo "$as_me:$LINENO: checking for $ac_word" >&5
4298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4299 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4300   echo $ECHO_N "(cached) $ECHO_C" >&6
4301 else
4302   if test -n "$GNATBIND"; then
4303   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4304 else
4305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4306 for as_dir in $PATH
4307 do
4308   IFS=$as_save_IFS
4309   test -z "$as_dir" && as_dir=.
4310   for ac_exec_ext in '' $ac_executable_extensions; do
4311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4312     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4314     break 2
4315   fi
4316 done
4317 done
4318
4319 fi
4320 fi
4321 GNATBIND=$ac_cv_prog_GNATBIND
4322 if test -n "$GNATBIND"; then
4323   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4324 echo "${ECHO_T}$GNATBIND" >&6
4325 else
4326   echo "$as_me:$LINENO: result: no" >&5
4327 echo "${ECHO_T}no" >&6
4328 fi
4329
4330 fi
4331 if test -z "$ac_cv_prog_GNATBIND"; then
4332   ac_ct_GNATBIND=$GNATBIND
4333   # Extract the first word of "gnatbind", so it can be a program name with args.
4334 set dummy gnatbind; ac_word=$2
4335 echo "$as_me:$LINENO: checking for $ac_word" >&5
4336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4337 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4338   echo $ECHO_N "(cached) $ECHO_C" >&6
4339 else
4340   if test -n "$ac_ct_GNATBIND"; then
4341   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4342 else
4343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4344 for as_dir in $PATH
4345 do
4346   IFS=$as_save_IFS
4347   test -z "$as_dir" && as_dir=.
4348   for ac_exec_ext in '' $ac_executable_extensions; do
4349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4350     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4352     break 2
4353   fi
4354 done
4355 done
4356
4357   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4358 fi
4359 fi
4360 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4361 if test -n "$ac_ct_GNATBIND"; then
4362   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4363 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4364 else
4365   echo "$as_me:$LINENO: result: no" >&5
4366 echo "${ECHO_T}no" >&6
4367 fi
4368
4369   GNATBIND=$ac_ct_GNATBIND
4370 else
4371   GNATBIND="$ac_cv_prog_GNATBIND"
4372 fi
4373
4374 if test -n "$ac_tool_prefix"; then
4375   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4376 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4377 echo "$as_me:$LINENO: checking for $ac_word" >&5
4378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4379 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4380   echo $ECHO_N "(cached) $ECHO_C" >&6
4381 else
4382   if test -n "$GNATMAKE"; then
4383   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4384 else
4385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4386 for as_dir in $PATH
4387 do
4388   IFS=$as_save_IFS
4389   test -z "$as_dir" && as_dir=.
4390   for ac_exec_ext in '' $ac_executable_extensions; do
4391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4392     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4394     break 2
4395   fi
4396 done
4397 done
4398
4399 fi
4400 fi
4401 GNATMAKE=$ac_cv_prog_GNATMAKE
4402 if test -n "$GNATMAKE"; then
4403   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4404 echo "${ECHO_T}$GNATMAKE" >&6
4405 else
4406   echo "$as_me:$LINENO: result: no" >&5
4407 echo "${ECHO_T}no" >&6
4408 fi
4409
4410 fi
4411 if test -z "$ac_cv_prog_GNATMAKE"; then
4412   ac_ct_GNATMAKE=$GNATMAKE
4413   # Extract the first word of "gnatmake", so it can be a program name with args.
4414 set dummy gnatmake; ac_word=$2
4415 echo "$as_me:$LINENO: checking for $ac_word" >&5
4416 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4417 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4418   echo $ECHO_N "(cached) $ECHO_C" >&6
4419 else
4420   if test -n "$ac_ct_GNATMAKE"; then
4421   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4422 else
4423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4424 for as_dir in $PATH
4425 do
4426   IFS=$as_save_IFS
4427   test -z "$as_dir" && as_dir=.
4428   for ac_exec_ext in '' $ac_executable_extensions; do
4429   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4430     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4431     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4432     break 2
4433   fi
4434 done
4435 done
4436
4437   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4438 fi
4439 fi
4440 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4441 if test -n "$ac_ct_GNATMAKE"; then
4442   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4443 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4444 else
4445   echo "$as_me:$LINENO: result: no" >&5
4446 echo "${ECHO_T}no" >&6
4447 fi
4448
4449   GNATMAKE=$ac_ct_GNATMAKE
4450 else
4451   GNATMAKE="$ac_cv_prog_GNATMAKE"
4452 fi
4453
4454 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4455 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4456 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4457   echo $ECHO_N "(cached) $ECHO_C" >&6
4458 else
4459   cat >conftest.adb <<EOF
4460 procedure conftest is begin null; end conftest;
4461 EOF
4462 acx_cv_cc_gcc_supports_ada=no
4463 # There is a bug in old released versions of GCC which causes the
4464 # driver to exit successfully when the appropriate language module
4465 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4466 # Therefore we must check for the error message as well as an
4467 # unsuccessful exit.
4468 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4469 # given a .adb file, but produce no object file.  So we must check
4470 # if an object file was really produced to guard against this.
4471 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4472 if test x"$errors" = x && test -f conftest.$ac_objext; then
4473   acx_cv_cc_gcc_supports_ada=yes
4474 fi
4475 rm -f conftest.*
4476 fi
4477 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4478 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4479
4480 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4481   have_gnat=yes
4482 else
4483   have_gnat=no
4484 fi
4485
4486 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4487 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4488 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4489   echo $ECHO_N "(cached) $ECHO_C" >&6
4490 else
4491    echo abfoo >t1
4492   echo cdfoo >t2
4493   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4494   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4495     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4496       :
4497     else
4498       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4499     fi
4500   fi
4501   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4502     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4503       :
4504     else
4505       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4506     fi
4507   fi
4508   rm t1 t2
4509
4510 fi
4511 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4512 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4513 do_compare="$gcc_cv_prog_cmp_skip"
4514
4515
4516
4517 # See if we are building gcc with C++.
4518 # Check whether --enable-build-with-cxx or --disable-build-with-cxx was given.
4519 if test "${enable_build_with_cxx+set}" = set; then
4520   enableval="$enable_build_with_cxx"
4521   ENABLE_BUILD_WITH_CXX=$enableval
4522 else
4523   ENABLE_BUILD_WITH_CXX=no
4524 fi;
4525
4526 # Check for GMP, MPFR and MPC
4527 gmplibs="-lmpfr -lgmp"
4528 gmpinc=
4529 have_gmp=no
4530 mpclibs=-lmpc
4531 mpcinc=
4532 have_mpc=no
4533
4534 # Specify a location for mpc
4535 # check for this first so it ends up on the link line before mpfr.
4536
4537 # Check whether --with-mpc or --without-mpc was given.
4538 if test "${with_mpc+set}" = set; then
4539   withval="$with_mpc"
4540
4541 fi;
4542
4543 # Check whether --with-mpc_include or --without-mpc_include was given.
4544 if test "${with_mpc_include+set}" = set; then
4545   withval="$with_mpc_include"
4546
4547 fi;
4548
4549 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4550 if test "${with_mpc_lib+set}" = set; then
4551   withval="$with_mpc_lib"
4552
4553 fi;
4554
4555 if test "x$with_mpc" != x; then
4556   mpclibs="-L$with_mpc/lib -lmpc"
4557   mpcinc="-I$with_mpc/include $mpcinc"
4558 fi
4559 if test "x$with_mpc_include" != x; then
4560   mpcinc="-I$with_mpc_include $mpcinc"
4561 fi
4562 if test "x$with_mpc_lib" != x; then
4563   mpclibs="-L$with_mpc_lib -lmpc"
4564 fi
4565 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4566   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4567   mpcinc='-I$$s/mpc/src '"$mpcinc"
4568   # Do not test the mpc version.  Assume that it is sufficient, since
4569   # it is in the source tree, and the library has not been built yet
4570   # but it would be included on the link line in the version check below
4571   # hence making the test fail.
4572   have_mpc=yes
4573 fi
4574
4575 # Specify a location for mpfr
4576 # check for this first so it ends up on the link line before gmp.
4577
4578 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4579 if test "${with_mpfr_dir+set}" = set; then
4580   withval="$with_mpfr_dir"
4581   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4582 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4583 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4584 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4585    { (exit 1); exit 1; }; }
4586 fi;
4587
4588
4589 # Check whether --with-mpfr or --without-mpfr was given.
4590 if test "${with_mpfr+set}" = set; then
4591   withval="$with_mpfr"
4592
4593 fi;
4594
4595 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4596 if test "${with_mpfr_include+set}" = set; then
4597   withval="$with_mpfr_include"
4598
4599 fi;
4600
4601 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4602 if test "${with_mpfr_lib+set}" = set; then
4603   withval="$with_mpfr_lib"
4604
4605 fi;
4606
4607 if test "x$with_mpfr" != x; then
4608   gmplibs="-L$with_mpfr/lib $gmplibs"
4609   gmpinc="-I$with_mpfr/include"
4610 fi
4611 if test "x$with_mpfr_include" != x; then
4612   gmpinc="-I$with_mpfr_include"
4613 fi
4614 if test "x$with_mpfr_lib" != x; then
4615   gmplibs="-L$with_mpfr_lib $gmplibs"
4616 fi
4617 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4618   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4619   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4620   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4621   # Do not test the mpfr version.  Assume that it is sufficient, since
4622   # it is in the source tree, and the library has not been built yet
4623   # but it would be included on the link line in the version check below
4624   # hence making the test fail.
4625   have_gmp=yes
4626 fi
4627
4628 # Specify a location for gmp
4629
4630 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4631 if test "${with_gmp_dir+set}" = set; then
4632   withval="$with_gmp_dir"
4633   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4634 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4635 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4636 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4637    { (exit 1); exit 1; }; }
4638 fi;
4639
4640
4641 # Check whether --with-gmp or --without-gmp was given.
4642 if test "${with_gmp+set}" = set; then
4643   withval="$with_gmp"
4644
4645 fi;
4646
4647 # Check whether --with-gmp_include or --without-gmp_include was given.
4648 if test "${with_gmp_include+set}" = set; then
4649   withval="$with_gmp_include"
4650
4651 fi;
4652
4653 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4654 if test "${with_gmp_lib+set}" = set; then
4655   withval="$with_gmp_lib"
4656
4657 fi;
4658
4659
4660 if test "x$with_gmp" != x; then
4661   gmplibs="-L$with_gmp/lib $gmplibs"
4662   gmpinc="-I$with_gmp/include $gmpinc"
4663 fi
4664 if test "x$with_gmp_include" != x; then
4665   gmpinc="-I$with_gmp_include $gmpinc"
4666 fi
4667 if test "x$with_gmp_lib" != x; then
4668   gmplibs="-L$with_gmp_lib $gmplibs"
4669 fi
4670 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4671   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4672   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4673   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4674   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4675   # Do not test the gmp version.  Assume that it is sufficient, since
4676   # it is in the source tree, and the library has not been built yet
4677   # but it would be included on the link line in the version check below
4678   # hence making the test fail.
4679   have_gmp=yes
4680 fi
4681
4682 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4683   have_gmp=yes
4684   saved_CFLAGS="$CFLAGS"
4685   CFLAGS="$CFLAGS $gmpinc"
4686   # Check GMP actually works
4687   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4688 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4689
4690 cat >conftest.$ac_ext <<_ACEOF
4691 /* confdefs.h.  */
4692 _ACEOF
4693 cat confdefs.h >>conftest.$ac_ext
4694 cat >>conftest.$ac_ext <<_ACEOF
4695 /* end confdefs.h.  */
4696 #include "gmp.h"
4697 int
4698 main ()
4699 {
4700
4701   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4702   choke me
4703   #endif
4704
4705   ;
4706   return 0;
4707 }
4708 _ACEOF
4709 rm -f conftest.$ac_objext
4710 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4711   (eval $ac_compile) 2>conftest.er1
4712   ac_status=$?
4713   grep -v '^ *+' conftest.er1 >conftest.err
4714   rm -f conftest.er1
4715   cat conftest.err >&5
4716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4717   (exit $ac_status); } &&
4718          { ac_try='test -z "$ac_c_werror_flag"
4719                          || test ! -s conftest.err'
4720   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4721   (eval $ac_try) 2>&5
4722   ac_status=$?
4723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4724   (exit $ac_status); }; } &&
4725          { ac_try='test -s conftest.$ac_objext'
4726   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4727   (eval $ac_try) 2>&5
4728   ac_status=$?
4729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4730   (exit $ac_status); }; }; then
4731   echo "$as_me:$LINENO: result: yes" >&5
4732 echo "${ECHO_T}yes" >&6
4733 else
4734   echo "$as_me: failed program was:" >&5
4735 sed 's/^/| /' conftest.$ac_ext >&5
4736
4737 echo "$as_me:$LINENO: result: no" >&5
4738 echo "${ECHO_T}no" >&6; have_gmp=no
4739 fi
4740 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4741
4742   # If we have GMP, check the MPFR version.
4743   if test x"$have_gmp" = xyes; then
4744         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4745 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4746     cat >conftest.$ac_ext <<_ACEOF
4747 /* confdefs.h.  */
4748 _ACEOF
4749 cat confdefs.h >>conftest.$ac_ext
4750 cat >>conftest.$ac_ext <<_ACEOF
4751 /* end confdefs.h.  */
4752 #include <gmp.h>
4753     #include <mpfr.h>
4754 int
4755 main ()
4756 {
4757
4758     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4759     choke me
4760     #endif
4761
4762   ;
4763   return 0;
4764 }
4765 _ACEOF
4766 rm -f conftest.$ac_objext
4767 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4768   (eval $ac_compile) 2>conftest.er1
4769   ac_status=$?
4770   grep -v '^ *+' conftest.er1 >conftest.err
4771   rm -f conftest.er1
4772   cat conftest.err >&5
4773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4774   (exit $ac_status); } &&
4775          { ac_try='test -z "$ac_c_werror_flag"
4776                          || test ! -s conftest.err'
4777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4778   (eval $ac_try) 2>&5
4779   ac_status=$?
4780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4781   (exit $ac_status); }; } &&
4782          { ac_try='test -s conftest.$ac_objext'
4783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4784   (eval $ac_try) 2>&5
4785   ac_status=$?
4786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4787   (exit $ac_status); }; }; then
4788   cat >conftest.$ac_ext <<_ACEOF
4789 /* confdefs.h.  */
4790 _ACEOF
4791 cat confdefs.h >>conftest.$ac_ext
4792 cat >>conftest.$ac_ext <<_ACEOF
4793 /* end confdefs.h.  */
4794 #include <gmp.h>
4795     #include <mpfr.h>
4796 int
4797 main ()
4798 {
4799
4800     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4801     choke me
4802     #endif
4803
4804   ;
4805   return 0;
4806 }
4807 _ACEOF
4808 rm -f conftest.$ac_objext
4809 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4810   (eval $ac_compile) 2>conftest.er1
4811   ac_status=$?
4812   grep -v '^ *+' conftest.er1 >conftest.err
4813   rm -f conftest.er1
4814   cat conftest.err >&5
4815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4816   (exit $ac_status); } &&
4817          { ac_try='test -z "$ac_c_werror_flag"
4818                          || test ! -s conftest.err'
4819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4820   (eval $ac_try) 2>&5
4821   ac_status=$?
4822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4823   (exit $ac_status); }; } &&
4824          { ac_try='test -s conftest.$ac_objext'
4825   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4826   (eval $ac_try) 2>&5
4827   ac_status=$?
4828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4829   (exit $ac_status); }; }; then
4830   echo "$as_me:$LINENO: result: yes" >&5
4831 echo "${ECHO_T}yes" >&6
4832 else
4833   echo "$as_me: failed program was:" >&5
4834 sed 's/^/| /' conftest.$ac_ext >&5
4835
4836 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4837 echo "${ECHO_T}buggy but acceptable" >&6
4838 fi
4839 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4840 else
4841   echo "$as_me: failed program was:" >&5
4842 sed 's/^/| /' conftest.$ac_ext >&5
4843
4844 echo "$as_me:$LINENO: result: no" >&5
4845 echo "${ECHO_T}no" >&6; have_gmp=no
4846 fi
4847 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4848   fi
4849
4850   # Check for the MPC header version.
4851   if test x"$have_mpc" != xyes ; then
4852     CFLAGS="$CFLAGS $mpcinc"
4853     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4854 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4855     cat >conftest.$ac_ext <<_ACEOF
4856 /* confdefs.h.  */
4857 _ACEOF
4858 cat confdefs.h >>conftest.$ac_ext
4859 cat >>conftest.$ac_ext <<_ACEOF
4860 /* end confdefs.h.  */
4861 #include <mpc.h>
4862 int
4863 main ()
4864 {
4865
4866     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4867     choke me
4868     #endif
4869
4870   ;
4871   return 0;
4872 }
4873 _ACEOF
4874 rm -f conftest.$ac_objext
4875 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4876   (eval $ac_compile) 2>conftest.er1
4877   ac_status=$?
4878   grep -v '^ *+' conftest.er1 >conftest.err
4879   rm -f conftest.er1
4880   cat conftest.err >&5
4881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4882   (exit $ac_status); } &&
4883          { ac_try='test -z "$ac_c_werror_flag"
4884                          || test ! -s conftest.err'
4885   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4886   (eval $ac_try) 2>&5
4887   ac_status=$?
4888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4889   (exit $ac_status); }; } &&
4890          { ac_try='test -s conftest.$ac_objext'
4891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4892   (eval $ac_try) 2>&5
4893   ac_status=$?
4894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4895   (exit $ac_status); }; }; then
4896   echo "$as_me:$LINENO: result: yes" >&5
4897 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4898 else
4899   echo "$as_me: failed program was:" >&5
4900 sed 's/^/| /' conftest.$ac_ext >&5
4901
4902 echo "$as_me:$LINENO: result: no" >&5
4903 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4904 fi
4905 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4906   fi
4907
4908   # Now check the MPFR library.
4909   if test x"$have_gmp" = xyes; then
4910     saved_LIBS="$LIBS"
4911     LIBS="$LIBS $gmplibs"
4912     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4913 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4914     cat >conftest.$ac_ext <<_ACEOF
4915 /* confdefs.h.  */
4916 _ACEOF
4917 cat confdefs.h >>conftest.$ac_ext
4918 cat >>conftest.$ac_ext <<_ACEOF
4919 /* end confdefs.h.  */
4920 #include <gmp.h>
4921     #include <mpfr.h>
4922 int
4923 main ()
4924 {
4925
4926     mpfr_t n;
4927     mpfr_t x;
4928     int t;
4929     mpfr_init (n);
4930     mpfr_init (x);
4931     mpfr_atan2 (n, n, x, GMP_RNDN);
4932     mpfr_erfc (n, x, GMP_RNDN);
4933     mpfr_subnormalize (x, t, GMP_RNDN);
4934
4935   ;
4936   return 0;
4937 }
4938 _ACEOF
4939 rm -f conftest.$ac_objext conftest$ac_exeext
4940 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4941   (eval $ac_link) 2>conftest.er1
4942   ac_status=$?
4943   grep -v '^ *+' conftest.er1 >conftest.err
4944   rm -f conftest.er1
4945   cat conftest.err >&5
4946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4947   (exit $ac_status); } &&
4948          { ac_try='test -z "$ac_c_werror_flag"
4949                          || test ! -s conftest.err'
4950   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4951   (eval $ac_try) 2>&5
4952   ac_status=$?
4953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4954   (exit $ac_status); }; } &&
4955          { ac_try='test -s conftest$ac_exeext'
4956   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4957   (eval $ac_try) 2>&5
4958   ac_status=$?
4959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4960   (exit $ac_status); }; }; then
4961   echo "$as_me:$LINENO: result: yes" >&5
4962 echo "${ECHO_T}yes" >&6
4963 else
4964   echo "$as_me: failed program was:" >&5
4965 sed 's/^/| /' conftest.$ac_ext >&5
4966
4967 echo "$as_me:$LINENO: result: no" >&5
4968 echo "${ECHO_T}no" >&6; have_gmp=no
4969 fi
4970 rm -f conftest.err conftest.$ac_objext \
4971       conftest$ac_exeext conftest.$ac_ext
4972     LIBS="$saved_LIBS"
4973   fi
4974
4975   if test x"$have_mpc" = xmaybe; then
4976     saved_LIBS="$LIBS"
4977     LIBS="$LIBS $mpclibs $gmplibs"
4978     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4979 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4980     cat >conftest.$ac_ext <<_ACEOF
4981 /* confdefs.h.  */
4982 _ACEOF
4983 cat confdefs.h >>conftest.$ac_ext
4984 cat >>conftest.$ac_ext <<_ACEOF
4985 /* end confdefs.h.  */
4986 #include <mpc.h>
4987 int
4988 main ()
4989 {
4990
4991     mpc_t n;
4992     mpc_init2 (n, 53);
4993     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
4994     mpc_sin (n, n, MPC_RNDNN);
4995     mpc_cos (n, n, MPC_RNDNN);
4996     mpc_tan (n, n, MPC_RNDNN);
4997     mpc_sinh (n, n, MPC_RNDNN);
4998     mpc_cosh (n, n, MPC_RNDNN);
4999     mpc_tanh (n, n, MPC_RNDNN);
5000     mpc_exp (n, n, MPC_RNDNN);
5001     mpc_log (n, n, MPC_RNDNN);
5002     mpc_sqrt (n, n, MPC_RNDNN);
5003     mpc_proj (n, n, MPC_RNDNN);
5004     mpc_neg (n, n, MPC_RNDNN);
5005     mpc_sqr (n, n, MPC_RNDNN);
5006     mpc_clear (n);
5007
5008   ;
5009   return 0;
5010 }
5011 _ACEOF
5012 rm -f conftest.$ac_objext conftest$ac_exeext
5013 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5014   (eval $ac_link) 2>conftest.er1
5015   ac_status=$?
5016   grep -v '^ *+' conftest.er1 >conftest.err
5017   rm -f conftest.er1
5018   cat conftest.err >&5
5019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5020   (exit $ac_status); } &&
5021          { ac_try='test -z "$ac_c_werror_flag"
5022                          || test ! -s conftest.err'
5023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5024   (eval $ac_try) 2>&5
5025   ac_status=$?
5026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5027   (exit $ac_status); }; } &&
5028          { ac_try='test -s conftest$ac_exeext'
5029   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5030   (eval $ac_try) 2>&5
5031   ac_status=$?
5032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5033   (exit $ac_status); }; }; then
5034   echo "$as_me:$LINENO: result: yes" >&5
5035 echo "${ECHO_T}yes" >&6; have_mpc=yes
5036 else
5037   echo "$as_me: failed program was:" >&5
5038 sed 's/^/| /' conftest.$ac_ext >&5
5039
5040 echo "$as_me:$LINENO: result: no" >&5
5041 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5042 fi
5043 rm -f conftest.err conftest.$ac_objext \
5044       conftest$ac_exeext conftest.$ac_ext
5045     LIBS="$saved_LIBS"
5046   fi
5047
5048   CFLAGS="$saved_CFLAGS"
5049
5050   if test x$have_gmp != xyes; then
5051     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5052 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5053 Copies of these libraries' source code can be found at their respective
5054 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5055 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5056 If you obtained GMP and/or MPFR from a vendor distribution package, make
5057 sure that you have installed both the libraries and the header files.
5058 They may be located in separate packages." >&5
5059 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5060 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5061 Copies of these libraries' source code can be found at their respective
5062 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5063 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5064 If you obtained GMP and/or MPFR from a vendor distribution package, make
5065 sure that you have installed both the libraries and the header files.
5066 They may be located in separate packages." >&2;}
5067    { (exit 1); exit 1; }; }
5068   fi
5069 fi
5070
5071 if test x$have_mpc != xyes ; then
5072   mpcinc=
5073   mpclibs=
5074 fi
5075
5076 gmpinc="$mpcinc $gmpinc"
5077 gmplibs="$mpclibs $gmplibs"
5078
5079 # Flags needed for both GMP, MPFR and/or MPC.
5080
5081
5082
5083
5084
5085
5086 # Allow host libstdc++ to be specified for static linking with PPL.
5087
5088 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5089 if test "${with_host_libstdcxx+set}" = set; then
5090   withval="$with_host_libstdcxx"
5091
5092 fi;
5093
5094 case $with_host_libstdcxx in
5095   no|yes)
5096     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5097 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5098    { (exit 1); exit 1; }; }
5099     ;;
5100 esac
5101
5102 # Linker flags to use for stage1 or when not boostrapping.
5103
5104 # Check whether --with-stage1-ldflags or --without-stage1-ldflags was given.
5105 if test "${with_stage1_ldflags+set}" = set; then
5106   withval="$with_stage1_ldflags"
5107   if test "$withval" = "no" -o "$withval" = "yes"; then
5108    stage1_ldflags=
5109  else
5110    stage1_ldflags=$withval
5111  fi
5112 else
5113   stage1_ldflags=
5114 fi;
5115
5116
5117 # Libraries to use for stage1 or when not bootstrapping.
5118
5119 # Check whether --with-stage1-libs or --without-stage1-libs was given.
5120 if test "${with_stage1_libs+set}" = set; then
5121   withval="$with_stage1_libs"
5122   if test "$withval" = "no" -o "$withval" = "yes"; then
5123    stage1_libs=
5124  else
5125    stage1_libs=$withval
5126  fi
5127 else
5128   stage1_libs=$with_host_libstdcxx
5129 fi;
5130
5131
5132 # Linker flags to use for stage2 and later builds.
5133
5134 # Check whether --with-boot-ldflags or --without-boot-ldflags was given.
5135 if test "${with_boot_ldflags+set}" = set; then
5136   withval="$with_boot_ldflags"
5137   if test "$withval" = "no" -o "$withval" = "yes"; then
5138    poststage1_ldflags=
5139  else
5140    poststage1_ldflags=$withval
5141  fi
5142 else
5143   if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5144    poststage1_ldflags=-static-libstdc++
5145  else
5146    poststage1_ldflags=
5147  fi
5148 fi;
5149
5150
5151 # Libraries to use for stage2 and later builds.  This defaults to the
5152 # argument passed to --with-host-libstdcxx.
5153
5154 # Check whether --with-boot-libs or --without-boot-libs was given.
5155 if test "${with_boot_libs+set}" = set; then
5156   withval="$with_boot_libs"
5157   if test "$withval" = "no" -o "$withval" = "yes"; then
5158    poststage1_libs=
5159  else
5160    poststage1_libs=$withval
5161  fi
5162 else
5163   poststage1_libs=$with_host_libstdcxx
5164 fi;
5165
5166
5167 # Check for PPL
5168 ppl_major_version=0
5169 ppl_minor_version=10
5170 ppllibs=" -lppl_c -lppl -lgmpxx"
5171 pplinc=
5172
5173
5174 # Check whether --with-ppl or --without-ppl was given.
5175 if test "${with_ppl+set}" = set; then
5176   withval="$with_ppl"
5177
5178 else
5179   with_ppl=no
5180 fi;
5181
5182 # Check whether --with-ppl_include or --without-ppl_include was given.
5183 if test "${with_ppl_include+set}" = set; then
5184   withval="$with_ppl_include"
5185
5186 fi;
5187
5188 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5189 if test "${with_ppl_lib+set}" = set; then
5190   withval="$with_ppl_lib"
5191
5192 fi;
5193
5194 case $with_ppl in
5195   no)
5196     ppllibs=
5197     ;;
5198   *)
5199     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
5200     pplinc="-I$with_ppl/include $pplinc"
5201     LIBS="$ppllibs $LIBS"
5202     ;;
5203 esac
5204 if test "x$with_ppl_include" != x; then
5205   pplinc="-I$with_ppl_include $pplinc"
5206 fi
5207 if test "x$with_ppl_lib" != x; then
5208   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
5209   LIBS="$ppllibs $LIBS"
5210 fi
5211 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5212   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
5213   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5214   LIBS="$ppllibs $LIBS"
5215 fi
5216
5217 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5218 if test "${enable_ppl_version_check+set}" = set; then
5219   enableval="$enable_ppl_version_check"
5220   ENABLE_PPL_CHECK=$enableval
5221 else
5222   ENABLE_PPL_CHECK=yes
5223 fi;
5224
5225 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5226   saved_CFLAGS="$CFLAGS"
5227   CFLAGS="$CFLAGS $pplinc $gmpinc"
5228   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5229 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5230   cat >conftest.$ac_ext <<_ACEOF
5231 /* confdefs.h.  */
5232 _ACEOF
5233 cat confdefs.h >>conftest.$ac_ext
5234 cat >>conftest.$ac_ext <<_ACEOF
5235 /* end confdefs.h.  */
5236 #include "ppl_c.h"
5237 int
5238 main ()
5239 {
5240
5241   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5242   choke me
5243   #endif
5244
5245   ;
5246   return 0;
5247 }
5248 _ACEOF
5249 rm -f conftest.$ac_objext
5250 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5251   (eval $ac_compile) 2>conftest.er1
5252   ac_status=$?
5253   grep -v '^ *+' conftest.er1 >conftest.err
5254   rm -f conftest.er1
5255   cat conftest.err >&5
5256   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5257   (exit $ac_status); } &&
5258          { ac_try='test -z "$ac_c_werror_flag"
5259                          || test ! -s conftest.err'
5260   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5261   (eval $ac_try) 2>&5
5262   ac_status=$?
5263   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5264   (exit $ac_status); }; } &&
5265          { ac_try='test -s conftest.$ac_objext'
5266   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5267   (eval $ac_try) 2>&5
5268   ac_status=$?
5269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5270   (exit $ac_status); }; }; then
5271   echo "$as_me:$LINENO: result: yes" >&5
5272 echo "${ECHO_T}yes" >&6
5273 else
5274   echo "$as_me: failed program was:" >&5
5275 sed 's/^/| /' conftest.$ac_ext >&5
5276
5277 echo "$as_me:$LINENO: result: no" >&5
5278 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5279 fi
5280 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5281   CFLAGS="$saved_CFLAGS"
5282 fi
5283
5284 # Flags needed for PPL
5285
5286
5287
5288
5289 # Check for CLOOG
5290 clooglibs=" -lcloog "
5291 clooginc=" -DCLOOG_PPL_BACKEND "
5292
5293
5294 # Check whether --with-cloog or --without-cloog was given.
5295 if test "${with_cloog+set}" = set; then
5296   withval="$with_cloog"
5297
5298 else
5299   with_cloog=no
5300 fi;
5301
5302 # Check whether --with-cloog_include or --without-cloog_include was given.
5303 if test "${with_cloog_include+set}" = set; then
5304   withval="$with_cloog_include"
5305
5306 fi;
5307
5308 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5309 if test "${with_cloog_lib+set}" = set; then
5310   withval="$with_cloog_lib"
5311
5312 fi;
5313
5314 case $with_cloog in
5315   no)
5316     clooglibs=
5317     clooginc=
5318     ;;
5319   *)
5320     clooglibs="-L$with_cloog/lib -lcloog"
5321     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5322     LIBS="$clooglibs $LIBS"
5323     ;;
5324 esac
5325 if test "x$with_cloog_include" != x; then
5326   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5327 fi
5328 if test "x$with_cloog_lib" != x; then
5329   clooglibs="-L$with_cloog_lib -lcloog"
5330   LIBS="$clooglibs $LIBS"
5331 fi
5332 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5333   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5334   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5335   LIBS="$clooglibs $LIBS"
5336 fi
5337
5338 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5339 if test "${enable_cloog_version_check+set}" = set; then
5340   enableval="$enable_cloog_version_check"
5341   ENABLE_CLOOG_CHECK=$enableval
5342 else
5343   ENABLE_CLOOG_CHECK=yes
5344 fi;
5345
5346 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5347   saved_CFLAGS="$CFLAGS"
5348   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5349   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5350 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5351   cat >conftest.$ac_ext <<_ACEOF
5352 /* confdefs.h.  */
5353 _ACEOF
5354 cat confdefs.h >>conftest.$ac_ext
5355 cat >>conftest.$ac_ext <<_ACEOF
5356 /* end confdefs.h.  */
5357 #include "cloog/cloog.h"
5358 int
5359 main ()
5360 {
5361
5362   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5363   choke me
5364   #endif
5365
5366   ;
5367   return 0;
5368 }
5369 _ACEOF
5370 rm -f conftest.$ac_objext
5371 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5372   (eval $ac_compile) 2>conftest.er1
5373   ac_status=$?
5374   grep -v '^ *+' conftest.er1 >conftest.err
5375   rm -f conftest.er1
5376   cat conftest.err >&5
5377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5378   (exit $ac_status); } &&
5379          { ac_try='test -z "$ac_c_werror_flag"
5380                          || test ! -s conftest.err'
5381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5382   (eval $ac_try) 2>&5
5383   ac_status=$?
5384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5385   (exit $ac_status); }; } &&
5386          { ac_try='test -s conftest.$ac_objext'
5387   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5388   (eval $ac_try) 2>&5
5389   ac_status=$?
5390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5391   (exit $ac_status); }; }; then
5392   echo "$as_me:$LINENO: result: yes" >&5
5393 echo "${ECHO_T}yes" >&6
5394 else
5395   echo "$as_me: failed program was:" >&5
5396 sed 's/^/| /' conftest.$ac_ext >&5
5397
5398 echo "$as_me:$LINENO: result: no" >&5
5399 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5400 fi
5401 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5402   CFLAGS="$saved_CFLAGS"
5403 fi
5404
5405 # Flags needed for CLOOG
5406
5407
5408
5409
5410 # By default, C is the only stage 1 language.
5411 stage1_languages=,c,
5412
5413 # Target libraries that we bootstrap.
5414 bootstrap_target_libs=,target-libgcc,
5415
5416 # Figure out what language subdirectories are present.
5417 # Look if the user specified --enable-languages="..."; if not, use
5418 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5419 # go away some day.
5420 # NB:  embedded tabs in this IF block -- do not untabify
5421 if test -d ${srcdir}/gcc; then
5422   if test x"${enable_languages+set}" != xset; then
5423     if test x"${LANGUAGES+set}" = xset; then
5424       enable_languages="${LANGUAGES}"
5425         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5426     else
5427       enable_languages=all
5428     fi
5429   else
5430     if test x"${enable_languages}" = x ||
5431        test x"${enable_languages}" = xyes;
5432        then
5433       echo configure.in: --enable-languages needs at least one language argument 1>&2
5434       exit 1
5435     fi
5436   fi
5437   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5438
5439   # 'f95' is the old name for the 'fortran' language. We issue a warning
5440   # and make the substitution.
5441   case ,${enable_languages}, in
5442     *,f95,*)
5443       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5444       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5445       ;;
5446   esac
5447
5448   # First scan to see if an enabled language requires some other language.
5449   # We assume that a given config-lang.in will list all the language
5450   # front ends it requires, even if some are required indirectly.
5451   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5452     case ${lang_frag} in
5453       ..) ;;
5454       # The odd quoting in the next line works around
5455       # an apparent bug in bash 1.12 on linux.
5456       ${srcdir}/gcc/[*]/config-lang.in) ;;
5457       *)
5458         # From the config-lang.in, get $language, $lang_requires
5459         language=
5460         lang_requires=
5461         . ${lang_frag}
5462         for other in ${lang_requires} ; do
5463           case ,${enable_languages}, in
5464             *,$other,*) ;;
5465             *,all,*) ;;
5466             *,$language,*)
5467               echo " \`$other' language required by \`$language'; enabling" 1>&2
5468               enable_languages="${enable_languages},${other}"
5469               ;;
5470           esac
5471         done
5472         ;;
5473     esac
5474   done
5475
5476   new_enable_languages=,c,
5477   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5478   potential_languages=,c,
5479
5480   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5481     case ${lang_frag} in
5482       ..) ;;
5483       # The odd quoting in the next line works around
5484       # an apparent bug in bash 1.12 on linux.
5485       ${srcdir}/gcc/[*]/config-lang.in) ;;
5486       *)
5487         # From the config-lang.in, get $language, $target_libs,
5488         # $lang_dirs, $boot_language, and $build_by_default
5489         language=
5490         target_libs=
5491         lang_dirs=
5492         subdir_requires=
5493         boot_language=no
5494         build_by_default=yes
5495         . ${lang_frag}
5496         if test x${language} = x; then
5497           echo "${lang_frag} doesn't set \$language." 1>&2
5498           exit 1
5499         fi
5500
5501         if test "$language" = "c++" -a "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5502           boot_language=yes
5503         fi
5504
5505         case ,${enable_languages}, in
5506           *,${language},*)
5507             # Language was explicitly selected; include it.
5508             add_this_lang=yes
5509             ;;
5510           *,all,*)
5511             # 'all' was selected, select it if it is a default language
5512             add_this_lang=${build_by_default}
5513             ;;
5514           *)
5515             add_this_lang=no
5516             ;;
5517         esac
5518
5519         # Disable languages that need other directories if these aren't available.
5520         for i in $subdir_requires; do
5521           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5522           case ,${enable_languages}, in
5523             *,${language},*)
5524               # Specifically requested language; tell them.
5525               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5526 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5527    { (exit 1); exit 1; }; }
5528               ;;
5529             *)
5530               # Silently disable.
5531               add_this_lang=unsupported
5532               ;;
5533           esac
5534         done
5535
5536         # Disable Ada if no preexisting GNAT is available.
5537         case ,${enable_languages},:${language}:${have_gnat} in
5538           *,${language},*:ada:no)
5539             # Specifically requested language; tell them.
5540             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5541 echo "$as_me: error: GNAT is required to build $language" >&2;}
5542    { (exit 1); exit 1; }; }
5543             ;;
5544           *:ada:no)
5545             # Silently disable.
5546             add_this_lang=unsupported
5547             ;;
5548         esac
5549
5550         # Disable a language that is unsupported by the target.
5551         case " $unsupported_languages " in
5552           *" $language "*)
5553             add_this_lang=unsupported
5554             ;;
5555         esac
5556
5557         case $add_this_lang in
5558           unsupported)
5559             # Remove language-dependent dirs.
5560             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5561             ;;
5562           no)
5563             # Remove language-dependent dirs; still show language as supported.
5564             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5565             potential_languages="${potential_languages}${language},"
5566             ;;
5567           yes)
5568             new_enable_languages="${new_enable_languages}${language},"
5569             potential_languages="${potential_languages}${language},"
5570             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5571             case ${boot_language} in
5572               yes)
5573                 # Add to (comma-separated) list of stage 1 languages.
5574                 stage1_languages="${stage1_languages}${language},"
5575                 # We need to bootstrap any supporting libraries.
5576                 bootstrap_target_libs="${bootstrap_target_libs}${target_libs},"
5577                 ;;
5578             esac
5579             ;;
5580         esac
5581         ;;
5582     esac
5583   done
5584
5585   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5586 if test "${enable_stage1_languages+set}" = set; then
5587   enableval="$enable_stage1_languages"
5588   case ,${enable_stage1_languages}, in
5589     ,no,|,,)
5590       # Set it to something that will have no effect in the loop below
5591       enable_stage1_languages=c ;;
5592     ,yes,)
5593       enable_stage1_languages=`echo $new_enable_languages | \
5594         sed -e "s/^,//" -e "s/,$//" ` ;;
5595     *,all,*)
5596       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5597         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5598   esac
5599
5600   # Add "good" languages from enable_stage1_languages to stage1_languages,
5601   # while "bad" languages go in missing_languages.  Leave no duplicates.
5602   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5603     case $potential_languages in
5604       *,$i,*)
5605         case $stage1_languages in
5606           *,$i,*) ;;
5607           *) stage1_languages="$stage1_languages$i," ;;
5608         esac ;;
5609       *)
5610         case $missing_languages in
5611           *,$i,*) ;;
5612           *) missing_languages="$missing_languages$i," ;;
5613         esac ;;
5614      esac
5615   done
5616 fi;
5617
5618   # Remove leading/trailing commas that were added for simplicity
5619   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5620   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5621   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5622   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5623
5624   if test "x$missing_languages" != x; then
5625     { { echo "$as_me:$LINENO: error:
5626 The following requested languages could not be built: ${missing_languages}
5627 Supported languages are: ${potential_languages}" >&5
5628 echo "$as_me: error:
5629 The following requested languages could not be built: ${missing_languages}
5630 Supported languages are: ${potential_languages}" >&2;}
5631    { (exit 1); exit 1; }; }
5632   fi
5633   if test "x$new_enable_languages" != "x$enable_languages"; then
5634     echo The following languages will be built: ${new_enable_languages}
5635     enable_languages="$new_enable_languages"
5636   fi
5637
5638
5639   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5640 fi
5641
5642 # Handle --disable-<component> generically.
5643 for dir in $configdirs $build_configdirs $target_configdirs ; do
5644   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5645   varname=`echo $dirname | sed -e s/+/_/g`
5646   if eval test x\${enable_${varname}} "=" xno ; then
5647     noconfigdirs="$noconfigdirs $dir"
5648   fi
5649 done
5650
5651 # Check for Boehm's garbage collector
5652 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5653 if test "${enable_objc_gc+set}" = set; then
5654   enableval="$enable_objc_gc"
5655   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5656   *,objc,*:*:yes:*target-boehm-gc*)
5657     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5658 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5659    { (exit 1); exit 1; }; }
5660     ;;
5661 esac
5662 fi;
5663
5664 # Make sure we only build Boehm's garbage collector if required.
5665 case ,${enable_languages},:${enable_objc_gc} in
5666   *,objc,*:yes)
5667     # Keep target-boehm-gc if requested for Objective-C.
5668     ;;
5669   *)
5670     # Otherwise remove target-boehm-gc depending on target-libjava.
5671     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5672       noconfigdirs="$noconfigdirs target-boehm-gc"
5673     fi
5674     ;;
5675 esac
5676
5677 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5678 # $build_configdirs and $target_configdirs.
5679 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5680
5681 notsupp=""
5682 for dir in . $skipdirs $noconfigdirs ; do
5683   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5684   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5685     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5686     if test -r $srcdir/$dirname/configure ; then
5687       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5688         true
5689       else
5690         notsupp="$notsupp $dir"
5691       fi
5692     fi
5693   fi
5694   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5695     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5696     if test -r $srcdir/$dirname/configure ; then
5697       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5698         true
5699       else
5700         notsupp="$notsupp $dir"
5701       fi
5702     fi
5703   fi
5704   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5705     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5706     if test -r $srcdir/$dirname/configure ; then
5707       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5708         true
5709       else
5710         notsupp="$notsupp $dir"
5711       fi
5712     fi
5713   fi
5714 done
5715
5716 # Sometimes the tools are distributed with libiberty but with no other
5717 # libraries.  In that case, we don't want to build target-libiberty.
5718 # Don't let libgcc imply libiberty either.
5719 if test -n "${target_configdirs}" ; then
5720   libgcc=
5721   others=
5722   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5723     if test "$i" = "libgcc"; then
5724       libgcc=target-libgcc
5725     elif test "$i" != "libiberty" ; then
5726       if test -r $srcdir/$i/configure ; then
5727         others=yes;
5728         break;
5729       fi
5730     fi
5731   done
5732   if test -z "${others}" ; then
5733     target_configdirs=$libgcc
5734   fi
5735 fi
5736
5737 # Quietly strip out all directories which aren't configurable in this tree.
5738 # This relies on all configurable subdirectories being autoconfiscated, which
5739 # is now the case.
5740 build_configdirs_all="$build_configdirs"
5741 build_configdirs=
5742 for i in ${build_configdirs_all} ; do
5743   j=`echo $i | sed -e s/build-//g`
5744   if test -f ${srcdir}/$j/configure ; then
5745     build_configdirs="${build_configdirs} $i"
5746   fi
5747 done
5748
5749 configdirs_all="$configdirs"
5750 configdirs=
5751 for i in ${configdirs_all} ; do
5752   if test -f ${srcdir}/$i/configure ; then
5753     configdirs="${configdirs} $i"
5754   fi
5755 done
5756
5757 target_configdirs_all="$target_configdirs"
5758 target_configdirs=
5759 for i in ${target_configdirs_all} ; do
5760   j=`echo $i | sed -e s/target-//g`
5761   if test -f ${srcdir}/$j/configure ; then
5762     target_configdirs="${target_configdirs} $i"
5763   fi
5764 done
5765
5766 # Produce a warning message for the subdirs we can't configure.
5767 # This isn't especially interesting in the Cygnus tree, but in the individual
5768 # FSF releases, it's important to let people know when their machine isn't
5769 # supported by the one or two programs in a package.
5770
5771 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5772   # If $appdirs is non-empty, at least one of those directories must still
5773   # be configured, or we error out.  (E.g., if the gas release supports a
5774   # specified target in some subdirs but not the gas subdir, we shouldn't
5775   # pretend that all is well.)
5776   if test -n "$appdirs" ; then
5777     for dir in $appdirs ; do
5778       if test -r $dir/Makefile.in ; then
5779         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5780           appdirs=""
5781           break
5782         fi
5783         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5784           appdirs=""
5785           break
5786         fi
5787       fi
5788     done
5789     if test -n "$appdirs" ; then
5790       echo "*** This configuration is not supported by this package." 1>&2
5791       exit 1
5792     fi
5793   fi
5794   # Okay, some application will build, or we don't care to check.  Still
5795   # notify of subdirs not getting built.
5796   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5797   echo "    ${notsupp}" 1>&2
5798   echo "    (Any other directories should still work fine.)" 1>&2
5799 fi
5800
5801 case "$host" in
5802   *msdosdjgpp*)
5803     enable_gdbtk=no ;;
5804 esac
5805
5806 # To find our prefix, in gcc_cv_tool_prefix.
5807
5808 # The user is always right.
5809 if test "${PATH_SEPARATOR+set}" != set; then
5810   echo "#! /bin/sh" >conf$$.sh
5811   echo  "exit 0"   >>conf$$.sh
5812   chmod +x conf$$.sh
5813   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5814     PATH_SEPARATOR=';'
5815   else
5816     PATH_SEPARATOR=:
5817   fi
5818   rm -f conf$$.sh
5819 fi
5820
5821
5822
5823 if test "x$exec_prefix" = xNONE; then
5824         if test "x$prefix" = xNONE; then
5825                 gcc_cv_tool_prefix=$ac_default_prefix
5826         else
5827                 gcc_cv_tool_prefix=$prefix
5828         fi
5829 else
5830         gcc_cv_tool_prefix=$exec_prefix
5831 fi
5832
5833 # If there is no compiler in the tree, use the PATH only.  In any
5834 # case, if there is no compiler in the tree nobody should use
5835 # AS_FOR_TARGET and LD_FOR_TARGET.
5836 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5837     gcc_version=`cat $srcdir/gcc/BASE-VER`
5838     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5839     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5840     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5841     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5842     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5843     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5844 else
5845     gcc_cv_tool_dirs=
5846 fi
5847
5848 if test x$build = x$target && test -n "$md_exec_prefix"; then
5849         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5850 fi
5851
5852
5853
5854 copy_dirs=
5855
5856
5857 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5858 if test "${with_build_sysroot+set}" = set; then
5859   withval="$with_build_sysroot"
5860   if test x"$withval" != x ; then
5861      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5862    fi
5863 else
5864   SYSROOT_CFLAGS_FOR_TARGET=
5865 fi;
5866
5867
5868
5869 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5870 if test "${with_debug_prefix_map+set}" = set; then
5871   withval="$with_debug_prefix_map"
5872   if test x"$withval" != x; then
5873      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5874      for debug_map in $withval; do
5875        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5876      done
5877    fi
5878 else
5879   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5880 fi;
5881
5882
5883 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5884 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5885 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5886 # We want to ensure that TARGET libraries (which we know are built with
5887 # gcc) are built with "-O2 -g", so include those options when setting
5888 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5889 if test "x$CFLAGS_FOR_TARGET" = x; then
5890   CFLAGS_FOR_TARGET=$CFLAGS
5891   case " $CFLAGS " in
5892     *" -O2 "*) ;;
5893     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5894   esac
5895   case " $CFLAGS " in
5896     *" -g "* | *" -g3 "*) ;;
5897     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5898   esac
5899 fi
5900
5901
5902 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5903   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5904   case " $CXXFLAGS " in
5905     *" -O2 "*) ;;
5906     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5907   esac
5908   case " $CXXFLAGS " in
5909     *" -g "* | *" -g3 "*) ;;
5910     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5911   esac
5912 fi
5913
5914
5915 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5916 # the named directory are copied to $(tooldir)/sys-include.
5917 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5918   if test x${is_cross_compiler} = xno ; then
5919     echo 1>&2 '***' --with-headers is only supported when cross compiling
5920     exit 1
5921   fi
5922   if test x"${with_headers}" != xyes ; then
5923     x=${gcc_cv_tool_prefix}
5924     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5925   fi
5926 fi
5927
5928 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5929 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5930 # are permitted.
5931 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5932   if test x${is_cross_compiler} = xno ; then
5933     echo 1>&2 '***' --with-libs is only supported when cross compiling
5934     exit 1
5935   fi
5936   if test x"${with_libs}" != xyes ; then
5937     # Copy the libraries in reverse order, so that files in the first named
5938     # library override files in subsequent libraries.
5939     x=${gcc_cv_tool_prefix}
5940     for l in ${with_libs}; do
5941       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5942     done
5943   fi
5944 fi
5945
5946 # Set with_gnu_as and with_gnu_ld as appropriate.
5947 #
5948 # This is done by determining whether or not the appropriate directory
5949 # is available, and by checking whether or not specific configurations
5950 # have requested that this magic not happen.
5951 #
5952 # The command line options always override the explicit settings in
5953 # configure.in, and the settings in configure.in override this magic.
5954 #
5955 # If the default for a toolchain is to use GNU as and ld, and you don't
5956 # want to do that, then you should use the --without-gnu-as and
5957 # --without-gnu-ld options for the configure script.
5958
5959 if test x${use_gnu_as} = x &&
5960    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5961   with_gnu_as=yes
5962   extra_host_args="$extra_host_args --with-gnu-as"
5963 fi
5964
5965 if test x${use_gnu_ld} = x &&
5966    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5967   with_gnu_ld=yes
5968   extra_host_args="$extra_host_args --with-gnu-ld"
5969 fi
5970
5971 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5972 # can detect this case.
5973
5974 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5975   with_newlib=yes
5976   extra_host_args="$extra_host_args --with-newlib"
5977 fi
5978
5979 # Handle ${copy_dirs}
5980 set fnord ${copy_dirs}
5981 shift
5982 while test $# != 0 ; do
5983   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5984     :
5985   else
5986     echo Copying $1 to $2
5987
5988     # Use the install script to create the directory and all required
5989     # parent directories.
5990     if test -d $2 ; then
5991       :
5992     else
5993       echo >config.temp
5994       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5995     fi
5996
5997     # Copy the directory, assuming we have tar.
5998     # FIXME: Should we use B in the second tar?  Not all systems support it.
5999     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
6000
6001     # It is the responsibility of the user to correctly adjust all
6002     # symlinks.  If somebody can figure out how to handle them correctly
6003     # here, feel free to add the code.
6004
6005     echo $1 > $2/COPIED
6006   fi
6007   shift; shift
6008 done
6009
6010 # Determine a target-dependent exec_prefix that the installed
6011 # gcc will search in.  Keep this list sorted by triplet, with
6012 # the *-*-osname triplets last.
6013 md_exec_prefix=
6014 case "${target}" in
6015   alpha*-*-*vms*)
6016     md_exec_prefix=/gnu/lib/gcc-lib
6017     ;;
6018   i[34567]86-pc-msdosdjgpp*)
6019     md_exec_prefix=/dev/env/DJDIR/bin
6020     ;;
6021   i[34567]86-*-sco3.2v5*)
6022     if test $with_gnu_as = yes; then
6023       md_exec_prefix=/usr/gnu/bin
6024     else
6025       md_exec_prefix=/usr/ccs/bin/elf
6026     fi
6027     ;;
6028
6029   mn10300-*-* | \
6030   powerpc-*-chorusos* | \
6031   powerpc*-*-eabi* | \
6032   powerpc*-*-sysv* | \
6033   powerpc*-*-kaos* | \
6034   s390x-ibm-tpf*)
6035     md_exec_prefix=/usr/ccs/bin
6036     ;;
6037   sparc64-*-elf*)
6038     ;;
6039   v850*-*-*)
6040     md_exec_prefix=/usr/ccs/bin
6041     ;;
6042   xtensa*-*-elf*)
6043     ;;
6044
6045   *-*-beos* | \
6046   *-*-elf* | \
6047   *-*-hpux* | \
6048   *-*-netware* | \
6049   *-*-nto-qnx* | \
6050   *-*-rtems* | \
6051   *-*-solaris2* | \
6052   *-*-sysv[45]* | \
6053   *-*-vxworks* | \
6054   *-wrs-windiss)
6055     md_exec_prefix=/usr/ccs/bin
6056     ;;
6057 esac
6058
6059 extra_arflags_for_target=
6060 extra_nmflags_for_target=
6061 extra_ranlibflags_for_target=
6062 target_makefile_frag=/dev/null
6063 case "${target}" in
6064   mep*-*-*)
6065     target_makefile_frag="config/mt-mep"
6066     ;;
6067   spu-*-*)
6068     target_makefile_frag="config/mt-spu"
6069     ;;
6070   mips*-sde-elf*)
6071     target_makefile_frag="config/mt-sde"
6072     ;;
6073   mipsisa*-*-elfoabi*)
6074     target_makefile_frag="config/mt-mips-elfoabi"
6075     ;;
6076   mips*-*-*linux* | mips*-*-gnu*)
6077     target_makefile_frag="config/mt-mips-gnu"
6078     ;;
6079   *-*-netware*)
6080     target_makefile_frag="config/mt-netware"
6081     ;;
6082   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
6083     target_makefile_frag="config/mt-gnu"
6084     ;;
6085   *-*-aix4.[3456789]* | *-*-aix[56789].*)
6086     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
6087     # commands to handle both 32-bit and 64-bit objects.  These flags are
6088     # harmless if we're using GNU nm or ar.
6089     extra_arflags_for_target=" -X32_64"
6090     extra_nmflags_for_target=" -B -X32_64"
6091     ;;
6092   *-*-darwin*)
6093     # ranlib from Darwin requires the -c flag to look at common symbols.
6094     extra_ranlibflags_for_target=" -c"
6095     ;;
6096   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6097     target_makefile_frag="config/mt-wince"
6098     ;;
6099 esac
6100
6101 alphaieee_frag=/dev/null
6102 case $target in
6103   alpha*-*-*)
6104     # This just makes sure to use the -mieee option to build target libs.
6105     # This should probably be set individually by each library.
6106     alphaieee_frag="config/mt-alphaieee"
6107     ;;
6108 esac
6109
6110 # If --enable-target-optspace always use -Os instead of -O2 to build
6111 # the target libraries, similarly if it is not specified, use -Os
6112 # on selected platforms.
6113 ospace_frag=/dev/null
6114 case "${enable_target_optspace}:${target}" in
6115   yes:*)
6116     ospace_frag="config/mt-ospace"
6117     ;;
6118   :d30v-*)
6119     ospace_frag="config/mt-d30v"
6120     ;;
6121   :m32r-* | :d10v-* | :fr30-*)
6122     ospace_frag="config/mt-ospace"
6123     ;;
6124   no:* | :*)
6125     ;;
6126   *)
6127     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6128     ;;
6129 esac
6130
6131 # Default to using --with-stabs for certain targets.
6132 if test x${with_stabs} = x ; then
6133   case "${target}" in
6134   mips*-*-irix[56]*)
6135     ;;
6136   mips*-*-* | alpha*-*-osf*)
6137     with_stabs=yes;
6138     extra_host_args="${extra_host_args} --with-stabs"
6139     ;;
6140   esac
6141 fi
6142
6143 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6144 # them automatically.
6145 case "${host}" in
6146   hppa*64*-*-hpux11*)
6147     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6148     ;;
6149 esac
6150
6151 # Some systems (e.g., one of the i386-aix systems the gas testers are
6152 # using) don't handle "\$" correctly, so don't use it here.
6153 tooldir='${exec_prefix}'/${target_noncanonical}
6154 build_tooldir=${tooldir}
6155
6156 # Create a .gdbinit file which runs the one in srcdir
6157 # and tells GDB to look there for source files.
6158
6159 if test -r ${srcdir}/.gdbinit ; then
6160   case ${srcdir} in
6161     .) ;;
6162     *) cat > ./.gdbinit <<EOF
6163 # ${NO_EDIT}
6164 dir ${srcdir}
6165 dir .
6166 source ${srcdir}/.gdbinit
6167 EOF
6168     ;;
6169   esac
6170 fi
6171
6172 # Make sure that the compiler is able to generate an executable.  If it
6173 # can't, we are probably in trouble.  We don't care whether we can run the
6174 # executable--we might be using a cross compiler--we only care whether it
6175 # can be created.  At this point the main configure script has set CC.
6176 we_are_ok=no
6177 echo "int main () { return 0; }" > conftest.c
6178 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6179 if test $? = 0 ; then
6180   if test -s conftest || test -s conftest.exe ; then
6181     we_are_ok=yes
6182   fi
6183 fi
6184 case $we_are_ok in
6185   no)
6186     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6187     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6188     rm -f conftest*
6189     exit 1
6190     ;;
6191 esac
6192 rm -f conftest*
6193
6194 # The Solaris /usr/ucb/cc compiler does not appear to work.
6195 case "${host}" in
6196   sparc-sun-solaris2*)
6197       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6198       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6199           could_use=
6200           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6201           if test -d /opt/cygnus/bin ; then
6202               if test "$could_use" = "" ; then
6203                   could_use="/opt/cygnus/bin"
6204               else
6205                   could_use="$could_use or /opt/cygnus/bin"
6206               fi
6207           fi
6208         if test "$could_use" = "" ; then
6209             echo "Warning: compilation may fail because you're using"
6210             echo "/usr/ucb/cc.  You should change your PATH or CC "
6211             echo "variable and rerun configure."
6212         else
6213             echo "Warning: compilation may fail because you're using"
6214             echo "/usr/ucb/cc, when you should use the C compiler from"
6215             echo "$could_use.  You should change your"
6216             echo "PATH or CC variable and rerun configure."
6217         fi
6218       fi
6219   ;;
6220 esac
6221
6222 # Decide which environment variable is used to find dynamic libraries.
6223 case "${host}" in
6224   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6225   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6226   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6227   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6228 esac
6229
6230 # On systems where the dynamic library environment variable is PATH,
6231 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6232 # built executables to PATH.
6233 if test "$RPATH_ENVVAR" = PATH; then
6234   GCC_SHLIB_SUBDIR=/shlib
6235 else
6236   GCC_SHLIB_SUBDIR=
6237 fi
6238
6239 # Record target_configdirs and the configure arguments for target and
6240 # build configuration in Makefile.
6241 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6242 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6243
6244 # Determine whether gdb needs tk/tcl or not.
6245 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6246 # and in that case we want gdb to be built without tk.  Ugh!
6247 # In fact I believe gdb is the *only* package directly dependent on tk,
6248 # so we should be able to put the 'maybe's in unconditionally and
6249 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6250 # 100% sure that that's safe though.
6251
6252 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6253 case "$enable_gdbtk" in
6254   no)
6255     GDB_TK="" ;;
6256   yes)
6257     GDB_TK="${gdb_tk}" ;;
6258   *)
6259     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6260     # distro.  Eventually someone will fix this and move Insight, nee
6261     # gdbtk to a separate directory.
6262     if test -d ${srcdir}/gdb/gdbtk ; then
6263       GDB_TK="${gdb_tk}"
6264     else
6265       GDB_TK=""
6266     fi
6267     ;;
6268 esac
6269 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6270 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6271
6272 # Strip out unwanted targets.
6273
6274 # While at that, we remove Makefiles if we were started for recursive
6275 # configuration, so that the top-level Makefile reconfigures them,
6276 # like we used to do when configure itself was recursive.
6277
6278 # Loop over modules.  $extrasub must be used with care, limiting as
6279 # much as possible the usage of range addresses.  That's because autoconf
6280 # splits the sed script to overcome limits in the number of commands,
6281 # and relying on carefully-timed sed passes may turn out to be very hard
6282 # to maintain later.  In this particular case, you just have to be careful
6283 # not to nest @if/@endif pairs, because configure will not warn you at all.
6284
6285 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6286 if test "${enable_bootstrap+set}" = set; then
6287   enableval="$enable_bootstrap"
6288
6289 else
6290   enable_bootstrap=default
6291 fi;
6292
6293 # Issue errors and warnings for invalid/strange bootstrap combinations.
6294 case "$configdirs" in
6295   *gcc*) have_compiler=yes ;;
6296   *) have_compiler=no ;;
6297 esac
6298
6299 case "$have_compiler:$host:$target:$enable_bootstrap" in
6300   *:*:*:no) ;;
6301
6302   # Default behavior.  Enable bootstrap if we have a compiler
6303   # and we are in a native configuration.
6304   yes:$build:$build:default)
6305     enable_bootstrap=yes ;;
6306
6307   *:*:*:default)
6308     enable_bootstrap=no ;;
6309
6310   # We have a compiler and we are in a native configuration, bootstrap is ok
6311   yes:$build:$build:yes)
6312     ;;
6313
6314   # Other configurations, but we have a compiler.  Assume the user knows
6315   # what he's doing.
6316   yes:*:*:yes)
6317     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6318 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6319     ;;
6320
6321   # No compiler: if they passed --enable-bootstrap explicitly, fail
6322   no:*:*:yes)
6323     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6324 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6325    { (exit 1); exit 1; }; } ;;
6326
6327   # Fail if wrong command line
6328   *)
6329     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6330 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6331    { (exit 1); exit 1; }; }
6332     ;;
6333 esac
6334
6335 # Adjust the toplevel makefile according to whether bootstrap was selected.
6336 case "$enable_bootstrap" in
6337   yes)
6338     bootstrap_suffix=bootstrap ;;
6339   no)
6340     bootstrap_suffix=no-bootstrap ;;
6341 esac
6342
6343 for module in ${build_configdirs} ; do
6344   if test -z "${no_recursion}" \
6345      && test -f ${build_subdir}/${module}/Makefile; then
6346     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6347     rm -f ${build_subdir}/${module}/Makefile
6348   fi
6349   extrasub="$extrasub
6350 /^@if build-$module\$/d
6351 /^@endif build-$module\$/d
6352 /^@if build-$module-$bootstrap_suffix\$/d
6353 /^@endif build-$module-$bootstrap_suffix\$/d"
6354 done
6355 for module in ${configdirs} ; do
6356   if test -z "${no_recursion}"; then
6357     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6358       if test -f ${file}; then
6359         echo 1>&2 "*** removing ${file} to force reconfigure"
6360         rm -f ${file}
6361       fi
6362     done
6363   fi
6364   extrasub="$extrasub
6365 /^@if $module\$/d
6366 /^@endif $module\$/d
6367 /^@if $module-$bootstrap_suffix\$/d
6368 /^@endif $module-$bootstrap_suffix\$/d"
6369 done
6370 for module in ${target_configdirs} ; do
6371   if test -z "${no_recursion}" \
6372      && test -f ${target_subdir}/${module}/Makefile; then
6373     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6374     rm -f ${target_subdir}/${module}/Makefile
6375   fi
6376
6377   # We only bootstrap target libraries listed in bootstrap_target_libs.
6378   case $bootstrap_target_libs in
6379     *,target-$module,*) target_bootstrap_suffix=$bootstrap_suffix ;;
6380     *) target_bootstrap_suffix=no-bootstrap ;;
6381   esac
6382
6383   extrasub="$extrasub
6384 /^@if target-$module\$/d
6385 /^@endif target-$module\$/d
6386 /^@if target-$module-$target_bootstrap_suffix\$/d
6387 /^@endif target-$module-$target_bootstrap_suffix\$/d"
6388 done
6389
6390 extrasub="$extrasub
6391 /^@if /,/^@endif /d"
6392
6393 # Create the serialization dependencies.  This uses a temporary file.
6394
6395 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6396 if test "${enable_serial_configure+set}" = set; then
6397   enableval="$enable_serial_configure"
6398
6399 fi;
6400
6401 case ${enable_serial_configure} in
6402   yes)
6403     enable_serial_build_configure=yes
6404     enable_serial_host_configure=yes
6405     enable_serial_target_configure=yes
6406     ;;
6407 esac
6408
6409 # These force 'configure's to be done one at a time, to avoid problems
6410 # with contention over a shared config.cache.
6411 rm -f serdep.tmp
6412 echo '# serdep.tmp' > serdep.tmp
6413 olditem=
6414 test "x${enable_serial_build_configure}" = xyes &&
6415 for item in ${build_configdirs} ; do
6416   case ${olditem} in
6417     "") ;;
6418     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6419   esac
6420   olditem=${item}
6421 done
6422 olditem=
6423 test "x${enable_serial_host_configure}" = xyes &&
6424 for item in ${configdirs} ; do
6425   case ${olditem} in
6426     "") ;;
6427     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6428   esac
6429   olditem=${item}
6430 done
6431 olditem=
6432 test "x${enable_serial_target_configure}" = xyes &&
6433 for item in ${target_configdirs} ; do
6434   case ${olditem} in
6435     "") ;;
6436     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6437   esac
6438   olditem=${item}
6439 done
6440 serialization_dependencies=serdep.tmp
6441
6442
6443 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6444 # target, nonopt, and variable assignments.  These are the ones we
6445 # might not want to pass down to subconfigures.  Also strip
6446 # program-prefix, program-suffix, and program-transform-name, so that
6447 # we can pass down a consistent program-transform-name.
6448 baseargs=
6449 keep_next=no
6450 skip_next=no
6451 eval "set -- $ac_configure_args"
6452 for ac_arg
6453 do
6454   if test X"$skip_next" = X"yes"; then
6455     skip_next=no
6456     continue
6457   fi
6458   if test X"$keep_next" = X"yes"; then
6459     case $ac_arg in
6460       *\'*)
6461         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6462     esac
6463     baseargs="$baseargs '$ac_arg'"
6464     keep_next=no
6465     continue
6466   fi
6467
6468   # Handle separated arguments.  Based on the logic generated by
6469   # autoconf 2.59.
6470   case $ac_arg in
6471     *=* | --config-cache | -C | -disable-* | --disable-* \
6472       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6473       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6474       | -with-* | --with-* | -without-* | --without-* | --x)
6475       separate_arg=no
6476       ;;
6477     -*)
6478       separate_arg=yes
6479       ;;
6480     *)
6481       separate_arg=no
6482       ;;
6483   esac
6484
6485   case "$ac_arg" in
6486     --no*)
6487       continue
6488       ;;
6489     --c* | \
6490     --sr* | \
6491     --ho* | \
6492     --bu* | \
6493     --t* | \
6494     --program-* | \
6495     -cache_file* | \
6496     -srcdir* | \
6497     -host* | \
6498     -build* | \
6499     -target* | \
6500     -program-prefix* | \
6501     -program-suffix* | \
6502     -program-transform-name* )
6503       skip_next=$separate_arg
6504       continue
6505       ;;
6506     -*)
6507       # An option.  Add it.
6508       case $ac_arg in
6509         *\'*)
6510           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6511       esac
6512       baseargs="$baseargs '$ac_arg'"
6513       keep_next=$separate_arg
6514       ;;
6515     *)
6516       # Either a variable assignment, or a nonopt (triplet).  Don't
6517       # pass it down; let the Makefile handle this.
6518       continue
6519       ;;
6520   esac
6521 done
6522 # Remove the initial space we just introduced and, as these will be
6523 # expanded by make, quote '$'.
6524 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6525
6526 # Add in --program-transform-name, after --program-prefix and
6527 # --program-suffix have been applied to it.  Autoconf has already
6528 # doubled dollar signs and backslashes in program_transform_name; we want
6529 # the backslashes un-doubled, and then the entire thing wrapped in single
6530 # quotes, because this will be expanded first by make and then by the shell.
6531 # Also, because we want to override the logic in subdir configure scripts to
6532 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6533 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6534 ${program_transform_name}
6535 EOF_SED
6536 gcc_transform_name=`cat conftestsed.out`
6537 rm -f conftestsed.out
6538 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6539 if test "$silent" = yes; then
6540   baseargs="$baseargs --silent"
6541 fi
6542
6543 # For the build-side libraries, we just need to pretend we're native,
6544 # and not use the same cache file.  Multilibs are neither needed nor
6545 # desired.
6546 build_configargs="--cache-file=../config.cache ${baseargs}"
6547
6548 # For host modules, accept cache file option, or specification as blank.
6549 case "${cache_file}" in
6550 "") # empty
6551   cache_file_option="" ;;
6552 /* | [A-Za-z]:[\\/]* ) # absolute path
6553   cache_file_option="--cache-file=${cache_file}" ;;
6554 *) # relative path
6555   cache_file_option="--cache-file=../${cache_file}" ;;
6556 esac
6557
6558 # Host dirs don't like to share a cache file either, horribly enough.
6559 # This seems to be due to autoconf 2.5x stupidity.
6560 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6561
6562 target_configargs=${baseargs}
6563
6564 # Passing a --with-cross-host argument lets the target libraries know
6565 # whether they are being built with a cross-compiler or being built
6566 # native.  However, it would be better to use other mechanisms to make the
6567 # sorts of decisions they want to make on this basis.  Please consider
6568 # this option to be deprecated.  FIXME.
6569 if test x${is_cross_compiler} = xyes ; then
6570   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6571 fi
6572
6573 # Default to --enable-multilib.
6574 if test x${enable_multilib} = x ; then
6575   target_configargs="--enable-multilib ${target_configargs}"
6576 fi
6577
6578 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6579 # changed from the earlier setting of with_newlib.
6580 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6581   target_configargs="--with-newlib ${target_configargs}"
6582 fi
6583
6584 # Different target subdirs use different values of certain variables
6585 # (notably CXX).  Worse, multilibs use *lots* of different values.
6586 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6587 # it doesn't automatically accept command-line overrides of them.
6588 # This means it's not safe for target subdirs to share a cache file,
6589 # which is disgusting, but there you have it.  Hopefully this can be
6590 # fixed in future.  It's still worthwhile to use a cache file for each
6591 # directory.  I think.
6592
6593 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6594 # We need to pass --target, as newer autoconf's requires consistency
6595 # for target_alias and gcc doesn't manage it consistently.
6596 target_configargs="--cache-file=./config.cache ${target_configargs}"
6597
6598 FLAGS_FOR_TARGET=
6599 case " $target_configdirs " in
6600  *" newlib "*)
6601   case " $target_configargs " in
6602   *" --with-newlib "*)
6603    case "$target" in
6604    *-cygwin*)
6605      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' ;;
6606    esac
6607
6608    # If we're not building GCC, don't discard standard headers.
6609    if test -d ${srcdir}/gcc; then
6610      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6611
6612      if test "${build}" != "${host}"; then
6613        # On Canadian crosses, CC_FOR_TARGET will have already been set
6614        # by `configure', so we won't have an opportunity to add -Bgcc/
6615        # to it.  This is right: we don't want to search that directory
6616        # for binaries, but we want the header files in there, so add
6617        # them explicitly.
6618        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6619
6620        # Someone might think of using the pre-installed headers on
6621        # Canadian crosses, in case the installed compiler is not fully
6622        # compatible with the compiler being built.  In this case, it
6623        # would be better to flag an error than risking having
6624        # incompatible object files being constructed.  We can't
6625        # guarantee that an error will be flagged, but let's hope the
6626        # compiler will do it, when presented with incompatible header
6627        # files.
6628      fi
6629    fi
6630
6631    case "${target}-${is_cross_compiler}" in
6632    i[3456789]86-*-linux*-no)
6633       # Here host == target, so we don't need to build gcc,
6634       # so we don't want to discard standard headers.
6635       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6636       ;;
6637    *)
6638       # If we're building newlib, use its generic headers last, but search
6639       # for any libc-related directories first (so make it the last -B
6640       # switch).
6641       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6642
6643       # If we're building libgloss, find the startup file, simulator library
6644       # and linker script.
6645       case " $target_configdirs " in
6646         *" libgloss "*)
6647         # Look for startup file, simulator library and maybe linker script.
6648         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6649         # Look for libnosys.a in case the target needs it.
6650         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6651         # Most targets have the linker script in the source directory.
6652         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6653         ;;
6654       esac
6655       ;;
6656    esac
6657    ;;
6658   esac
6659   ;;
6660 esac
6661 case "$target" in
6662 *-mingw*)
6663   # Can't be handled as Cygwin above since Mingw does not use newlib.
6664   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' ;;
6665 esac
6666
6667 # Allow the user to override the flags for
6668 # our build compiler if desired.
6669 if test x"${build}" = x"${host}" ; then
6670   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6671   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6672   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6673 fi
6674
6675 # On Canadian crosses, we'll be searching the right directories for
6676 # the previously-installed cross compiler, so don't bother to add
6677 # flags for directories within the install tree of the compiler
6678 # being built; programs in there won't even run.
6679 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6680   # Search for pre-installed headers if nothing else fits.
6681   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6682 fi
6683
6684 if test "x${use_gnu_ld}" = x &&
6685    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6686   # Arrange for us to find uninstalled linker scripts.
6687   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6688 fi
6689
6690 # Search for other target-specific linker scripts and such.
6691 case "${target}" in
6692   mep*)
6693     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6694     ;;
6695 esac
6696
6697 # Makefile fragments.
6698 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6699 do
6700   eval fragval=\$$frag
6701   if test $fragval != /dev/null; then
6702     eval $frag=${srcdir}/$fragval
6703   fi
6704 done
6705
6706
6707
6708
6709
6710 # Miscellanea: directories, flags, etc.
6711
6712
6713
6714
6715
6716
6717
6718
6719 # Build module lists & subconfigure args.
6720
6721
6722
6723 # Host module lists & subconfigure args.
6724
6725
6726
6727 # Target module lists & subconfigure args.
6728
6729
6730
6731 # Build tools.
6732
6733
6734
6735
6736
6737
6738
6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749 # Generate default definitions for YACC, M4, LEX and other programs that run
6750 # on the build machine.  These are used if the Makefile can't locate these
6751 # programs in objdir.
6752 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6753
6754 for ac_prog in 'bison -y' byacc yacc
6755 do
6756   # Extract the first word of "$ac_prog", so it can be a program name with args.
6757 set dummy $ac_prog; ac_word=$2
6758 echo "$as_me:$LINENO: checking for $ac_word" >&5
6759 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6760 if test "${ac_cv_prog_YACC+set}" = set; then
6761   echo $ECHO_N "(cached) $ECHO_C" >&6
6762 else
6763   if test -n "$YACC"; then
6764   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6765 else
6766 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6767 for as_dir in $PATH
6768 do
6769   IFS=$as_save_IFS
6770   test -z "$as_dir" && as_dir=.
6771   for ac_exec_ext in '' $ac_executable_extensions; do
6772   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6773     ac_cv_prog_YACC="$ac_prog"
6774     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6775     break 2
6776   fi
6777 done
6778 done
6779
6780 fi
6781 fi
6782 YACC=$ac_cv_prog_YACC
6783 if test -n "$YACC"; then
6784   echo "$as_me:$LINENO: result: $YACC" >&5
6785 echo "${ECHO_T}$YACC" >&6
6786 else
6787   echo "$as_me:$LINENO: result: no" >&5
6788 echo "${ECHO_T}no" >&6
6789 fi
6790
6791   test -n "$YACC" && break
6792 done
6793 test -n "$YACC" || YACC="$MISSING bison -y"
6794
6795 case " $build_configdirs " in
6796   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6797   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6798 esac
6799
6800 for ac_prog in bison
6801 do
6802   # Extract the first word of "$ac_prog", so it can be a program name with args.
6803 set dummy $ac_prog; ac_word=$2
6804 echo "$as_me:$LINENO: checking for $ac_word" >&5
6805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6806 if test "${ac_cv_prog_BISON+set}" = set; then
6807   echo $ECHO_N "(cached) $ECHO_C" >&6
6808 else
6809   if test -n "$BISON"; then
6810   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6811 else
6812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6813 for as_dir in $PATH
6814 do
6815   IFS=$as_save_IFS
6816   test -z "$as_dir" && as_dir=.
6817   for ac_exec_ext in '' $ac_executable_extensions; do
6818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6819     ac_cv_prog_BISON="$ac_prog"
6820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6821     break 2
6822   fi
6823 done
6824 done
6825
6826 fi
6827 fi
6828 BISON=$ac_cv_prog_BISON
6829 if test -n "$BISON"; then
6830   echo "$as_me:$LINENO: result: $BISON" >&5
6831 echo "${ECHO_T}$BISON" >&6
6832 else
6833   echo "$as_me:$LINENO: result: no" >&5
6834 echo "${ECHO_T}no" >&6
6835 fi
6836
6837   test -n "$BISON" && break
6838 done
6839 test -n "$BISON" || BISON="$MISSING bison"
6840
6841 case " $build_configdirs " in
6842   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6843 esac
6844
6845 for ac_prog in gm4 gnum4 m4
6846 do
6847   # Extract the first word of "$ac_prog", so it can be a program name with args.
6848 set dummy $ac_prog; ac_word=$2
6849 echo "$as_me:$LINENO: checking for $ac_word" >&5
6850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6851 if test "${ac_cv_prog_M4+set}" = set; then
6852   echo $ECHO_N "(cached) $ECHO_C" >&6
6853 else
6854   if test -n "$M4"; then
6855   ac_cv_prog_M4="$M4" # Let the user override the test.
6856 else
6857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6858 for as_dir in $PATH
6859 do
6860   IFS=$as_save_IFS
6861   test -z "$as_dir" && as_dir=.
6862   for ac_exec_ext in '' $ac_executable_extensions; do
6863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6864     ac_cv_prog_M4="$ac_prog"
6865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6866     break 2
6867   fi
6868 done
6869 done
6870
6871 fi
6872 fi
6873 M4=$ac_cv_prog_M4
6874 if test -n "$M4"; then
6875   echo "$as_me:$LINENO: result: $M4" >&5
6876 echo "${ECHO_T}$M4" >&6
6877 else
6878   echo "$as_me:$LINENO: result: no" >&5
6879 echo "${ECHO_T}no" >&6
6880 fi
6881
6882   test -n "$M4" && break
6883 done
6884 test -n "$M4" || M4="$MISSING m4"
6885
6886 case " $build_configdirs " in
6887   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6888 esac
6889
6890 for ac_prog in flex lex
6891 do
6892   # Extract the first word of "$ac_prog", so it can be a program name with args.
6893 set dummy $ac_prog; ac_word=$2
6894 echo "$as_me:$LINENO: checking for $ac_word" >&5
6895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6896 if test "${ac_cv_prog_LEX+set}" = set; then
6897   echo $ECHO_N "(cached) $ECHO_C" >&6
6898 else
6899   if test -n "$LEX"; then
6900   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6901 else
6902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6903 for as_dir in $PATH
6904 do
6905   IFS=$as_save_IFS
6906   test -z "$as_dir" && as_dir=.
6907   for ac_exec_ext in '' $ac_executable_extensions; do
6908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6909     ac_cv_prog_LEX="$ac_prog"
6910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6911     break 2
6912   fi
6913 done
6914 done
6915
6916 fi
6917 fi
6918 LEX=$ac_cv_prog_LEX
6919 if test -n "$LEX"; then
6920   echo "$as_me:$LINENO: result: $LEX" >&5
6921 echo "${ECHO_T}$LEX" >&6
6922 else
6923   echo "$as_me:$LINENO: result: no" >&5
6924 echo "${ECHO_T}no" >&6
6925 fi
6926
6927   test -n "$LEX" && break
6928 done
6929 test -n "$LEX" || LEX="$MISSING flex"
6930
6931 case " $build_configdirs " in
6932   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6933   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6934 esac
6935
6936 for ac_prog in flex
6937 do
6938   # Extract the first word of "$ac_prog", so it can be a program name with args.
6939 set dummy $ac_prog; ac_word=$2
6940 echo "$as_me:$LINENO: checking for $ac_word" >&5
6941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6942 if test "${ac_cv_prog_FLEX+set}" = set; then
6943   echo $ECHO_N "(cached) $ECHO_C" >&6
6944 else
6945   if test -n "$FLEX"; then
6946   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6947 else
6948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6949 for as_dir in $PATH
6950 do
6951   IFS=$as_save_IFS
6952   test -z "$as_dir" && as_dir=.
6953   for ac_exec_ext in '' $ac_executable_extensions; do
6954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6955     ac_cv_prog_FLEX="$ac_prog"
6956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6957     break 2
6958   fi
6959 done
6960 done
6961
6962 fi
6963 fi
6964 FLEX=$ac_cv_prog_FLEX
6965 if test -n "$FLEX"; then
6966   echo "$as_me:$LINENO: result: $FLEX" >&5
6967 echo "${ECHO_T}$FLEX" >&6
6968 else
6969   echo "$as_me:$LINENO: result: no" >&5
6970 echo "${ECHO_T}no" >&6
6971 fi
6972
6973   test -n "$FLEX" && break
6974 done
6975 test -n "$FLEX" || FLEX="$MISSING flex"
6976
6977 case " $build_configdirs " in
6978   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6979 esac
6980
6981 for ac_prog in makeinfo
6982 do
6983   # Extract the first word of "$ac_prog", so it can be a program name with args.
6984 set dummy $ac_prog; ac_word=$2
6985 echo "$as_me:$LINENO: checking for $ac_word" >&5
6986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6987 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6988   echo $ECHO_N "(cached) $ECHO_C" >&6
6989 else
6990   if test -n "$MAKEINFO"; then
6991   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6992 else
6993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6994 for as_dir in $PATH
6995 do
6996   IFS=$as_save_IFS
6997   test -z "$as_dir" && as_dir=.
6998   for ac_exec_ext in '' $ac_executable_extensions; do
6999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7000     ac_cv_prog_MAKEINFO="$ac_prog"
7001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7002     break 2
7003   fi
7004 done
7005 done
7006
7007 fi
7008 fi
7009 MAKEINFO=$ac_cv_prog_MAKEINFO
7010 if test -n "$MAKEINFO"; then
7011   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
7012 echo "${ECHO_T}$MAKEINFO" >&6
7013 else
7014   echo "$as_me:$LINENO: result: no" >&5
7015 echo "${ECHO_T}no" >&6
7016 fi
7017
7018   test -n "$MAKEINFO" && break
7019 done
7020 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
7021
7022 case " $build_configdirs " in
7023   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
7024   *)
7025
7026     # For an installed makeinfo, we require it to be from texinfo 4.7 or
7027     # higher, else we use the "missing" dummy.
7028     if ${MAKEINFO} --version \
7029        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
7030       :
7031     else
7032       MAKEINFO="$MISSING makeinfo"
7033     fi
7034     ;;
7035
7036 esac
7037
7038 # FIXME: expect and dejagnu may become build tools?
7039
7040 for ac_prog in expect
7041 do
7042   # Extract the first word of "$ac_prog", so it can be a program name with args.
7043 set dummy $ac_prog; ac_word=$2
7044 echo "$as_me:$LINENO: checking for $ac_word" >&5
7045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7046 if test "${ac_cv_prog_EXPECT+set}" = set; then
7047   echo $ECHO_N "(cached) $ECHO_C" >&6
7048 else
7049   if test -n "$EXPECT"; then
7050   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
7051 else
7052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7053 for as_dir in $PATH
7054 do
7055   IFS=$as_save_IFS
7056   test -z "$as_dir" && as_dir=.
7057   for ac_exec_ext in '' $ac_executable_extensions; do
7058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7059     ac_cv_prog_EXPECT="$ac_prog"
7060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7061     break 2
7062   fi
7063 done
7064 done
7065
7066 fi
7067 fi
7068 EXPECT=$ac_cv_prog_EXPECT
7069 if test -n "$EXPECT"; then
7070   echo "$as_me:$LINENO: result: $EXPECT" >&5
7071 echo "${ECHO_T}$EXPECT" >&6
7072 else
7073   echo "$as_me:$LINENO: result: no" >&5
7074 echo "${ECHO_T}no" >&6
7075 fi
7076
7077   test -n "$EXPECT" && break
7078 done
7079 test -n "$EXPECT" || EXPECT="expect"
7080
7081 case " $configdirs " in
7082   *" expect "*)
7083     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
7084     ;;
7085 esac
7086
7087 for ac_prog in runtest
7088 do
7089   # Extract the first word of "$ac_prog", so it can be a program name with args.
7090 set dummy $ac_prog; ac_word=$2
7091 echo "$as_me:$LINENO: checking for $ac_word" >&5
7092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7093 if test "${ac_cv_prog_RUNTEST+set}" = set; then
7094   echo $ECHO_N "(cached) $ECHO_C" >&6
7095 else
7096   if test -n "$RUNTEST"; then
7097   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
7098 else
7099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7100 for as_dir in $PATH
7101 do
7102   IFS=$as_save_IFS
7103   test -z "$as_dir" && as_dir=.
7104   for ac_exec_ext in '' $ac_executable_extensions; do
7105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7106     ac_cv_prog_RUNTEST="$ac_prog"
7107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7108     break 2
7109   fi
7110 done
7111 done
7112
7113 fi
7114 fi
7115 RUNTEST=$ac_cv_prog_RUNTEST
7116 if test -n "$RUNTEST"; then
7117   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7118 echo "${ECHO_T}$RUNTEST" >&6
7119 else
7120   echo "$as_me:$LINENO: result: no" >&5
7121 echo "${ECHO_T}no" >&6
7122 fi
7123
7124   test -n "$RUNTEST" && break
7125 done
7126 test -n "$RUNTEST" || RUNTEST="runtest"
7127
7128 case " $configdirs " in
7129   *" dejagnu "*)
7130     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7131     ;;
7132 esac
7133
7134
7135 # Host tools.
7136 ncn_tool_prefix=
7137 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7138 ncn_target_tool_prefix=
7139 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7140
7141
7142
7143 if test -n "$AR"; then
7144   ac_cv_prog_AR=$AR
7145 elif test -n "$ac_cv_prog_AR"; then
7146   AR=$ac_cv_prog_AR
7147 fi
7148
7149 if test -n "$ac_cv_prog_AR"; then
7150   for ncn_progname in ar; do
7151     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7152 set dummy ${ncn_progname}; ac_word=$2
7153 echo "$as_me:$LINENO: checking for $ac_word" >&5
7154 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7155 if test "${ac_cv_prog_AR+set}" = set; then
7156   echo $ECHO_N "(cached) $ECHO_C" >&6
7157 else
7158   if test -n "$AR"; then
7159   ac_cv_prog_AR="$AR" # Let the user override the test.
7160 else
7161 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7162 for as_dir in $PATH
7163 do
7164   IFS=$as_save_IFS
7165   test -z "$as_dir" && as_dir=.
7166   for ac_exec_ext in '' $ac_executable_extensions; do
7167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7168     ac_cv_prog_AR="${ncn_progname}"
7169     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7170     break 2
7171   fi
7172 done
7173 done
7174
7175 fi
7176 fi
7177 AR=$ac_cv_prog_AR
7178 if test -n "$AR"; then
7179   echo "$as_me:$LINENO: result: $AR" >&5
7180 echo "${ECHO_T}$AR" >&6
7181 else
7182   echo "$as_me:$LINENO: result: no" >&5
7183 echo "${ECHO_T}no" >&6
7184 fi
7185
7186   done
7187 fi
7188
7189 for ncn_progname in ar; do
7190   if test -n "$ncn_tool_prefix"; then
7191     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7192 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7193 echo "$as_me:$LINENO: checking for $ac_word" >&5
7194 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7195 if test "${ac_cv_prog_AR+set}" = set; then
7196   echo $ECHO_N "(cached) $ECHO_C" >&6
7197 else
7198   if test -n "$AR"; then
7199   ac_cv_prog_AR="$AR" # Let the user override the test.
7200 else
7201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7202 for as_dir in $PATH
7203 do
7204   IFS=$as_save_IFS
7205   test -z "$as_dir" && as_dir=.
7206   for ac_exec_ext in '' $ac_executable_extensions; do
7207   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7208     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7209     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7210     break 2
7211   fi
7212 done
7213 done
7214
7215 fi
7216 fi
7217 AR=$ac_cv_prog_AR
7218 if test -n "$AR"; then
7219   echo "$as_me:$LINENO: result: $AR" >&5
7220 echo "${ECHO_T}$AR" >&6
7221 else
7222   echo "$as_me:$LINENO: result: no" >&5
7223 echo "${ECHO_T}no" >&6
7224 fi
7225
7226   fi
7227   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7228     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7229 set dummy ${ncn_progname}; ac_word=$2
7230 echo "$as_me:$LINENO: checking for $ac_word" >&5
7231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7232 if test "${ac_cv_prog_AR+set}" = set; then
7233   echo $ECHO_N "(cached) $ECHO_C" >&6
7234 else
7235   if test -n "$AR"; then
7236   ac_cv_prog_AR="$AR" # Let the user override the test.
7237 else
7238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7239 for as_dir in $PATH
7240 do
7241   IFS=$as_save_IFS
7242   test -z "$as_dir" && as_dir=.
7243   for ac_exec_ext in '' $ac_executable_extensions; do
7244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7245     ac_cv_prog_AR="${ncn_progname}"
7246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7247     break 2
7248   fi
7249 done
7250 done
7251
7252 fi
7253 fi
7254 AR=$ac_cv_prog_AR
7255 if test -n "$AR"; then
7256   echo "$as_me:$LINENO: result: $AR" >&5
7257 echo "${ECHO_T}$AR" >&6
7258 else
7259   echo "$as_me:$LINENO: result: no" >&5
7260 echo "${ECHO_T}no" >&6
7261 fi
7262
7263   fi
7264   test -n "$ac_cv_prog_AR" && break
7265 done
7266
7267 if test -z "$ac_cv_prog_AR" ; then
7268   set dummy ar
7269   if test $build = $host ; then
7270     AR="$2"
7271   else
7272     AR="${ncn_tool_prefix}$2"
7273   fi
7274 fi
7275
7276
7277
7278 if test -n "$AS"; then
7279   ac_cv_prog_AS=$AS
7280 elif test -n "$ac_cv_prog_AS"; then
7281   AS=$ac_cv_prog_AS
7282 fi
7283
7284 if test -n "$ac_cv_prog_AS"; then
7285   for ncn_progname in as; do
7286     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7287 set dummy ${ncn_progname}; ac_word=$2
7288 echo "$as_me:$LINENO: checking for $ac_word" >&5
7289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7290 if test "${ac_cv_prog_AS+set}" = set; then
7291   echo $ECHO_N "(cached) $ECHO_C" >&6
7292 else
7293   if test -n "$AS"; then
7294   ac_cv_prog_AS="$AS" # Let the user override the test.
7295 else
7296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7297 for as_dir in $PATH
7298 do
7299   IFS=$as_save_IFS
7300   test -z "$as_dir" && as_dir=.
7301   for ac_exec_ext in '' $ac_executable_extensions; do
7302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7303     ac_cv_prog_AS="${ncn_progname}"
7304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7305     break 2
7306   fi
7307 done
7308 done
7309
7310 fi
7311 fi
7312 AS=$ac_cv_prog_AS
7313 if test -n "$AS"; then
7314   echo "$as_me:$LINENO: result: $AS" >&5
7315 echo "${ECHO_T}$AS" >&6
7316 else
7317   echo "$as_me:$LINENO: result: no" >&5
7318 echo "${ECHO_T}no" >&6
7319 fi
7320
7321   done
7322 fi
7323
7324 for ncn_progname in as; do
7325   if test -n "$ncn_tool_prefix"; then
7326     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7327 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7328 echo "$as_me:$LINENO: checking for $ac_word" >&5
7329 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7330 if test "${ac_cv_prog_AS+set}" = set; then
7331   echo $ECHO_N "(cached) $ECHO_C" >&6
7332 else
7333   if test -n "$AS"; then
7334   ac_cv_prog_AS="$AS" # Let the user override the test.
7335 else
7336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7337 for as_dir in $PATH
7338 do
7339   IFS=$as_save_IFS
7340   test -z "$as_dir" && as_dir=.
7341   for ac_exec_ext in '' $ac_executable_extensions; do
7342   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7343     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7344     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7345     break 2
7346   fi
7347 done
7348 done
7349
7350 fi
7351 fi
7352 AS=$ac_cv_prog_AS
7353 if test -n "$AS"; then
7354   echo "$as_me:$LINENO: result: $AS" >&5
7355 echo "${ECHO_T}$AS" >&6
7356 else
7357   echo "$as_me:$LINENO: result: no" >&5
7358 echo "${ECHO_T}no" >&6
7359 fi
7360
7361   fi
7362   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7363     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7364 set dummy ${ncn_progname}; ac_word=$2
7365 echo "$as_me:$LINENO: checking for $ac_word" >&5
7366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7367 if test "${ac_cv_prog_AS+set}" = set; then
7368   echo $ECHO_N "(cached) $ECHO_C" >&6
7369 else
7370   if test -n "$AS"; then
7371   ac_cv_prog_AS="$AS" # Let the user override the test.
7372 else
7373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7374 for as_dir in $PATH
7375 do
7376   IFS=$as_save_IFS
7377   test -z "$as_dir" && as_dir=.
7378   for ac_exec_ext in '' $ac_executable_extensions; do
7379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7380     ac_cv_prog_AS="${ncn_progname}"
7381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7382     break 2
7383   fi
7384 done
7385 done
7386
7387 fi
7388 fi
7389 AS=$ac_cv_prog_AS
7390 if test -n "$AS"; then
7391   echo "$as_me:$LINENO: result: $AS" >&5
7392 echo "${ECHO_T}$AS" >&6
7393 else
7394   echo "$as_me:$LINENO: result: no" >&5
7395 echo "${ECHO_T}no" >&6
7396 fi
7397
7398   fi
7399   test -n "$ac_cv_prog_AS" && break
7400 done
7401
7402 if test -z "$ac_cv_prog_AS" ; then
7403   set dummy as
7404   if test $build = $host ; then
7405     AS="$2"
7406   else
7407     AS="${ncn_tool_prefix}$2"
7408   fi
7409 fi
7410
7411
7412
7413 if test -n "$DLLTOOL"; then
7414   ac_cv_prog_DLLTOOL=$DLLTOOL
7415 elif test -n "$ac_cv_prog_DLLTOOL"; then
7416   DLLTOOL=$ac_cv_prog_DLLTOOL
7417 fi
7418
7419 if test -n "$ac_cv_prog_DLLTOOL"; then
7420   for ncn_progname in dlltool; do
7421     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7422 set dummy ${ncn_progname}; ac_word=$2
7423 echo "$as_me:$LINENO: checking for $ac_word" >&5
7424 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7425 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7426   echo $ECHO_N "(cached) $ECHO_C" >&6
7427 else
7428   if test -n "$DLLTOOL"; then
7429   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7430 else
7431 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7432 for as_dir in $PATH
7433 do
7434   IFS=$as_save_IFS
7435   test -z "$as_dir" && as_dir=.
7436   for ac_exec_ext in '' $ac_executable_extensions; do
7437   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7438     ac_cv_prog_DLLTOOL="${ncn_progname}"
7439     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7440     break 2
7441   fi
7442 done
7443 done
7444
7445 fi
7446 fi
7447 DLLTOOL=$ac_cv_prog_DLLTOOL
7448 if test -n "$DLLTOOL"; then
7449   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7450 echo "${ECHO_T}$DLLTOOL" >&6
7451 else
7452   echo "$as_me:$LINENO: result: no" >&5
7453 echo "${ECHO_T}no" >&6
7454 fi
7455
7456   done
7457 fi
7458
7459 for ncn_progname in dlltool; do
7460   if test -n "$ncn_tool_prefix"; then
7461     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7462 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7463 echo "$as_me:$LINENO: checking for $ac_word" >&5
7464 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7465 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7466   echo $ECHO_N "(cached) $ECHO_C" >&6
7467 else
7468   if test -n "$DLLTOOL"; then
7469   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7470 else
7471 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7472 for as_dir in $PATH
7473 do
7474   IFS=$as_save_IFS
7475   test -z "$as_dir" && as_dir=.
7476   for ac_exec_ext in '' $ac_executable_extensions; do
7477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7478     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7480     break 2
7481   fi
7482 done
7483 done
7484
7485 fi
7486 fi
7487 DLLTOOL=$ac_cv_prog_DLLTOOL
7488 if test -n "$DLLTOOL"; then
7489   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7490 echo "${ECHO_T}$DLLTOOL" >&6
7491 else
7492   echo "$as_me:$LINENO: result: no" >&5
7493 echo "${ECHO_T}no" >&6
7494 fi
7495
7496   fi
7497   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7498     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7499 set dummy ${ncn_progname}; ac_word=$2
7500 echo "$as_me:$LINENO: checking for $ac_word" >&5
7501 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7502 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7503   echo $ECHO_N "(cached) $ECHO_C" >&6
7504 else
7505   if test -n "$DLLTOOL"; then
7506   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7507 else
7508 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7509 for as_dir in $PATH
7510 do
7511   IFS=$as_save_IFS
7512   test -z "$as_dir" && as_dir=.
7513   for ac_exec_ext in '' $ac_executable_extensions; do
7514   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7515     ac_cv_prog_DLLTOOL="${ncn_progname}"
7516     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7517     break 2
7518   fi
7519 done
7520 done
7521
7522 fi
7523 fi
7524 DLLTOOL=$ac_cv_prog_DLLTOOL
7525 if test -n "$DLLTOOL"; then
7526   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7527 echo "${ECHO_T}$DLLTOOL" >&6
7528 else
7529   echo "$as_me:$LINENO: result: no" >&5
7530 echo "${ECHO_T}no" >&6
7531 fi
7532
7533   fi
7534   test -n "$ac_cv_prog_DLLTOOL" && break
7535 done
7536
7537 if test -z "$ac_cv_prog_DLLTOOL" ; then
7538   set dummy dlltool
7539   if test $build = $host ; then
7540     DLLTOOL="$2"
7541   else
7542     DLLTOOL="${ncn_tool_prefix}$2"
7543   fi
7544 fi
7545
7546
7547
7548 if test -n "$LD"; then
7549   ac_cv_prog_LD=$LD
7550 elif test -n "$ac_cv_prog_LD"; then
7551   LD=$ac_cv_prog_LD
7552 fi
7553
7554 if test -n "$ac_cv_prog_LD"; then
7555   for ncn_progname in ld; do
7556     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7557 set dummy ${ncn_progname}; ac_word=$2
7558 echo "$as_me:$LINENO: checking for $ac_word" >&5
7559 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7560 if test "${ac_cv_prog_LD+set}" = set; then
7561   echo $ECHO_N "(cached) $ECHO_C" >&6
7562 else
7563   if test -n "$LD"; then
7564   ac_cv_prog_LD="$LD" # Let the user override the test.
7565 else
7566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7567 for as_dir in $PATH
7568 do
7569   IFS=$as_save_IFS
7570   test -z "$as_dir" && as_dir=.
7571   for ac_exec_ext in '' $ac_executable_extensions; do
7572   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7573     ac_cv_prog_LD="${ncn_progname}"
7574     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7575     break 2
7576   fi
7577 done
7578 done
7579
7580 fi
7581 fi
7582 LD=$ac_cv_prog_LD
7583 if test -n "$LD"; then
7584   echo "$as_me:$LINENO: result: $LD" >&5
7585 echo "${ECHO_T}$LD" >&6
7586 else
7587   echo "$as_me:$LINENO: result: no" >&5
7588 echo "${ECHO_T}no" >&6
7589 fi
7590
7591   done
7592 fi
7593
7594 for ncn_progname in ld; do
7595   if test -n "$ncn_tool_prefix"; then
7596     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7597 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7598 echo "$as_me:$LINENO: checking for $ac_word" >&5
7599 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7600 if test "${ac_cv_prog_LD+set}" = set; then
7601   echo $ECHO_N "(cached) $ECHO_C" >&6
7602 else
7603   if test -n "$LD"; then
7604   ac_cv_prog_LD="$LD" # Let the user override the test.
7605 else
7606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7607 for as_dir in $PATH
7608 do
7609   IFS=$as_save_IFS
7610   test -z "$as_dir" && as_dir=.
7611   for ac_exec_ext in '' $ac_executable_extensions; do
7612   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7613     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7614     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7615     break 2
7616   fi
7617 done
7618 done
7619
7620 fi
7621 fi
7622 LD=$ac_cv_prog_LD
7623 if test -n "$LD"; then
7624   echo "$as_me:$LINENO: result: $LD" >&5
7625 echo "${ECHO_T}$LD" >&6
7626 else
7627   echo "$as_me:$LINENO: result: no" >&5
7628 echo "${ECHO_T}no" >&6
7629 fi
7630
7631   fi
7632   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7633     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7634 set dummy ${ncn_progname}; ac_word=$2
7635 echo "$as_me:$LINENO: checking for $ac_word" >&5
7636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7637 if test "${ac_cv_prog_LD+set}" = set; then
7638   echo $ECHO_N "(cached) $ECHO_C" >&6
7639 else
7640   if test -n "$LD"; then
7641   ac_cv_prog_LD="$LD" # Let the user override the test.
7642 else
7643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7644 for as_dir in $PATH
7645 do
7646   IFS=$as_save_IFS
7647   test -z "$as_dir" && as_dir=.
7648   for ac_exec_ext in '' $ac_executable_extensions; do
7649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7650     ac_cv_prog_LD="${ncn_progname}"
7651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7652     break 2
7653   fi
7654 done
7655 done
7656
7657 fi
7658 fi
7659 LD=$ac_cv_prog_LD
7660 if test -n "$LD"; then
7661   echo "$as_me:$LINENO: result: $LD" >&5
7662 echo "${ECHO_T}$LD" >&6
7663 else
7664   echo "$as_me:$LINENO: result: no" >&5
7665 echo "${ECHO_T}no" >&6
7666 fi
7667
7668   fi
7669   test -n "$ac_cv_prog_LD" && break
7670 done
7671
7672 if test -z "$ac_cv_prog_LD" ; then
7673   set dummy ld
7674   if test $build = $host ; then
7675     LD="$2"
7676   else
7677     LD="${ncn_tool_prefix}$2"
7678   fi
7679 fi
7680
7681
7682
7683 if test -n "$LIPO"; then
7684   ac_cv_prog_LIPO=$LIPO
7685 elif test -n "$ac_cv_prog_LIPO"; then
7686   LIPO=$ac_cv_prog_LIPO
7687 fi
7688
7689 if test -n "$ac_cv_prog_LIPO"; then
7690   for ncn_progname in lipo; do
7691     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7692 set dummy ${ncn_progname}; ac_word=$2
7693 echo "$as_me:$LINENO: checking for $ac_word" >&5
7694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7695 if test "${ac_cv_prog_LIPO+set}" = set; then
7696   echo $ECHO_N "(cached) $ECHO_C" >&6
7697 else
7698   if test -n "$LIPO"; then
7699   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7700 else
7701 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7702 for as_dir in $PATH
7703 do
7704   IFS=$as_save_IFS
7705   test -z "$as_dir" && as_dir=.
7706   for ac_exec_ext in '' $ac_executable_extensions; do
7707   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7708     ac_cv_prog_LIPO="${ncn_progname}"
7709     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7710     break 2
7711   fi
7712 done
7713 done
7714
7715 fi
7716 fi
7717 LIPO=$ac_cv_prog_LIPO
7718 if test -n "$LIPO"; then
7719   echo "$as_me:$LINENO: result: $LIPO" >&5
7720 echo "${ECHO_T}$LIPO" >&6
7721 else
7722   echo "$as_me:$LINENO: result: no" >&5
7723 echo "${ECHO_T}no" >&6
7724 fi
7725
7726   done
7727 fi
7728
7729 for ncn_progname in lipo; do
7730   if test -n "$ncn_tool_prefix"; then
7731     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7732 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7733 echo "$as_me:$LINENO: checking for $ac_word" >&5
7734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7735 if test "${ac_cv_prog_LIPO+set}" = set; then
7736   echo $ECHO_N "(cached) $ECHO_C" >&6
7737 else
7738   if test -n "$LIPO"; then
7739   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7740 else
7741 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7742 for as_dir in $PATH
7743 do
7744   IFS=$as_save_IFS
7745   test -z "$as_dir" && as_dir=.
7746   for ac_exec_ext in '' $ac_executable_extensions; do
7747   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7748     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7749     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7750     break 2
7751   fi
7752 done
7753 done
7754
7755 fi
7756 fi
7757 LIPO=$ac_cv_prog_LIPO
7758 if test -n "$LIPO"; then
7759   echo "$as_me:$LINENO: result: $LIPO" >&5
7760 echo "${ECHO_T}$LIPO" >&6
7761 else
7762   echo "$as_me:$LINENO: result: no" >&5
7763 echo "${ECHO_T}no" >&6
7764 fi
7765
7766   fi
7767   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7768     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7769 set dummy ${ncn_progname}; ac_word=$2
7770 echo "$as_me:$LINENO: checking for $ac_word" >&5
7771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7772 if test "${ac_cv_prog_LIPO+set}" = set; then
7773   echo $ECHO_N "(cached) $ECHO_C" >&6
7774 else
7775   if test -n "$LIPO"; then
7776   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7777 else
7778 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7779 for as_dir in $PATH
7780 do
7781   IFS=$as_save_IFS
7782   test -z "$as_dir" && as_dir=.
7783   for ac_exec_ext in '' $ac_executable_extensions; do
7784   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7785     ac_cv_prog_LIPO="${ncn_progname}"
7786     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7787     break 2
7788   fi
7789 done
7790 done
7791
7792 fi
7793 fi
7794 LIPO=$ac_cv_prog_LIPO
7795 if test -n "$LIPO"; then
7796   echo "$as_me:$LINENO: result: $LIPO" >&5
7797 echo "${ECHO_T}$LIPO" >&6
7798 else
7799   echo "$as_me:$LINENO: result: no" >&5
7800 echo "${ECHO_T}no" >&6
7801 fi
7802
7803   fi
7804   test -n "$ac_cv_prog_LIPO" && break
7805 done
7806
7807 if test -z "$ac_cv_prog_LIPO" ; then
7808   set dummy lipo
7809   if test $build = $host ; then
7810     LIPO="$2"
7811   else
7812     LIPO="${ncn_tool_prefix}$2"
7813   fi
7814 fi
7815
7816
7817
7818 if test -n "$NM"; then
7819   ac_cv_prog_NM=$NM
7820 elif test -n "$ac_cv_prog_NM"; then
7821   NM=$ac_cv_prog_NM
7822 fi
7823
7824 if test -n "$ac_cv_prog_NM"; then
7825   for ncn_progname in nm; do
7826     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7827 set dummy ${ncn_progname}; ac_word=$2
7828 echo "$as_me:$LINENO: checking for $ac_word" >&5
7829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7830 if test "${ac_cv_prog_NM+set}" = set; then
7831   echo $ECHO_N "(cached) $ECHO_C" >&6
7832 else
7833   if test -n "$NM"; then
7834   ac_cv_prog_NM="$NM" # Let the user override the test.
7835 else
7836 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7837 for as_dir in $PATH
7838 do
7839   IFS=$as_save_IFS
7840   test -z "$as_dir" && as_dir=.
7841   for ac_exec_ext in '' $ac_executable_extensions; do
7842   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7843     ac_cv_prog_NM="${ncn_progname}"
7844     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7845     break 2
7846   fi
7847 done
7848 done
7849
7850 fi
7851 fi
7852 NM=$ac_cv_prog_NM
7853 if test -n "$NM"; then
7854   echo "$as_me:$LINENO: result: $NM" >&5
7855 echo "${ECHO_T}$NM" >&6
7856 else
7857   echo "$as_me:$LINENO: result: no" >&5
7858 echo "${ECHO_T}no" >&6
7859 fi
7860
7861   done
7862 fi
7863
7864 for ncn_progname in nm; do
7865   if test -n "$ncn_tool_prefix"; then
7866     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7867 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7868 echo "$as_me:$LINENO: checking for $ac_word" >&5
7869 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7870 if test "${ac_cv_prog_NM+set}" = set; then
7871   echo $ECHO_N "(cached) $ECHO_C" >&6
7872 else
7873   if test -n "$NM"; then
7874   ac_cv_prog_NM="$NM" # Let the user override the test.
7875 else
7876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7877 for as_dir in $PATH
7878 do
7879   IFS=$as_save_IFS
7880   test -z "$as_dir" && as_dir=.
7881   for ac_exec_ext in '' $ac_executable_extensions; do
7882   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7883     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7884     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7885     break 2
7886   fi
7887 done
7888 done
7889
7890 fi
7891 fi
7892 NM=$ac_cv_prog_NM
7893 if test -n "$NM"; then
7894   echo "$as_me:$LINENO: result: $NM" >&5
7895 echo "${ECHO_T}$NM" >&6
7896 else
7897   echo "$as_me:$LINENO: result: no" >&5
7898 echo "${ECHO_T}no" >&6
7899 fi
7900
7901   fi
7902   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7903     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7904 set dummy ${ncn_progname}; ac_word=$2
7905 echo "$as_me:$LINENO: checking for $ac_word" >&5
7906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7907 if test "${ac_cv_prog_NM+set}" = set; then
7908   echo $ECHO_N "(cached) $ECHO_C" >&6
7909 else
7910   if test -n "$NM"; then
7911   ac_cv_prog_NM="$NM" # Let the user override the test.
7912 else
7913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7914 for as_dir in $PATH
7915 do
7916   IFS=$as_save_IFS
7917   test -z "$as_dir" && as_dir=.
7918   for ac_exec_ext in '' $ac_executable_extensions; do
7919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7920     ac_cv_prog_NM="${ncn_progname}"
7921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7922     break 2
7923   fi
7924 done
7925 done
7926
7927 fi
7928 fi
7929 NM=$ac_cv_prog_NM
7930 if test -n "$NM"; then
7931   echo "$as_me:$LINENO: result: $NM" >&5
7932 echo "${ECHO_T}$NM" >&6
7933 else
7934   echo "$as_me:$LINENO: result: no" >&5
7935 echo "${ECHO_T}no" >&6
7936 fi
7937
7938   fi
7939   test -n "$ac_cv_prog_NM" && break
7940 done
7941
7942 if test -z "$ac_cv_prog_NM" ; then
7943   set dummy nm
7944   if test $build = $host ; then
7945     NM="$2"
7946   else
7947     NM="${ncn_tool_prefix}$2"
7948   fi
7949 fi
7950
7951
7952
7953 if test -n "$RANLIB"; then
7954   ac_cv_prog_RANLIB=$RANLIB
7955 elif test -n "$ac_cv_prog_RANLIB"; then
7956   RANLIB=$ac_cv_prog_RANLIB
7957 fi
7958
7959 if test -n "$ac_cv_prog_RANLIB"; then
7960   for ncn_progname in ranlib; do
7961     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7962 set dummy ${ncn_progname}; ac_word=$2
7963 echo "$as_me:$LINENO: checking for $ac_word" >&5
7964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7965 if test "${ac_cv_prog_RANLIB+set}" = set; then
7966   echo $ECHO_N "(cached) $ECHO_C" >&6
7967 else
7968   if test -n "$RANLIB"; then
7969   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7970 else
7971 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7972 for as_dir in $PATH
7973 do
7974   IFS=$as_save_IFS
7975   test -z "$as_dir" && as_dir=.
7976   for ac_exec_ext in '' $ac_executable_extensions; do
7977   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7978     ac_cv_prog_RANLIB="${ncn_progname}"
7979     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7980     break 2
7981   fi
7982 done
7983 done
7984
7985 fi
7986 fi
7987 RANLIB=$ac_cv_prog_RANLIB
7988 if test -n "$RANLIB"; then
7989   echo "$as_me:$LINENO: result: $RANLIB" >&5
7990 echo "${ECHO_T}$RANLIB" >&6
7991 else
7992   echo "$as_me:$LINENO: result: no" >&5
7993 echo "${ECHO_T}no" >&6
7994 fi
7995
7996   done
7997 fi
7998
7999 for ncn_progname in ranlib; do
8000   if test -n "$ncn_tool_prefix"; then
8001     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8002 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8003 echo "$as_me:$LINENO: checking for $ac_word" >&5
8004 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8005 if test "${ac_cv_prog_RANLIB+set}" = set; then
8006   echo $ECHO_N "(cached) $ECHO_C" >&6
8007 else
8008   if test -n "$RANLIB"; then
8009   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8010 else
8011 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8012 for as_dir in $PATH
8013 do
8014   IFS=$as_save_IFS
8015   test -z "$as_dir" && as_dir=.
8016   for ac_exec_ext in '' $ac_executable_extensions; do
8017   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8018     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
8019     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8020     break 2
8021   fi
8022 done
8023 done
8024
8025 fi
8026 fi
8027 RANLIB=$ac_cv_prog_RANLIB
8028 if test -n "$RANLIB"; then
8029   echo "$as_me:$LINENO: result: $RANLIB" >&5
8030 echo "${ECHO_T}$RANLIB" >&6
8031 else
8032   echo "$as_me:$LINENO: result: no" >&5
8033 echo "${ECHO_T}no" >&6
8034 fi
8035
8036   fi
8037   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
8038     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8039 set dummy ${ncn_progname}; ac_word=$2
8040 echo "$as_me:$LINENO: checking for $ac_word" >&5
8041 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8042 if test "${ac_cv_prog_RANLIB+set}" = set; then
8043   echo $ECHO_N "(cached) $ECHO_C" >&6
8044 else
8045   if test -n "$RANLIB"; then
8046   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8047 else
8048 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8049 for as_dir in $PATH
8050 do
8051   IFS=$as_save_IFS
8052   test -z "$as_dir" && as_dir=.
8053   for ac_exec_ext in '' $ac_executable_extensions; do
8054   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8055     ac_cv_prog_RANLIB="${ncn_progname}"
8056     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8057     break 2
8058   fi
8059 done
8060 done
8061
8062 fi
8063 fi
8064 RANLIB=$ac_cv_prog_RANLIB
8065 if test -n "$RANLIB"; then
8066   echo "$as_me:$LINENO: result: $RANLIB" >&5
8067 echo "${ECHO_T}$RANLIB" >&6
8068 else
8069   echo "$as_me:$LINENO: result: no" >&5
8070 echo "${ECHO_T}no" >&6
8071 fi
8072
8073   fi
8074   test -n "$ac_cv_prog_RANLIB" && break
8075 done
8076
8077 if test -z "$ac_cv_prog_RANLIB" ; then
8078   RANLIB=":"
8079 fi
8080
8081
8082
8083 if test -n "$STRIP"; then
8084   ac_cv_prog_STRIP=$STRIP
8085 elif test -n "$ac_cv_prog_STRIP"; then
8086   STRIP=$ac_cv_prog_STRIP
8087 fi
8088
8089 if test -n "$ac_cv_prog_STRIP"; then
8090   for ncn_progname in strip; do
8091     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8092 set dummy ${ncn_progname}; ac_word=$2
8093 echo "$as_me:$LINENO: checking for $ac_word" >&5
8094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8095 if test "${ac_cv_prog_STRIP+set}" = set; then
8096   echo $ECHO_N "(cached) $ECHO_C" >&6
8097 else
8098   if test -n "$STRIP"; then
8099   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8100 else
8101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8102 for as_dir in $PATH
8103 do
8104   IFS=$as_save_IFS
8105   test -z "$as_dir" && as_dir=.
8106   for ac_exec_ext in '' $ac_executable_extensions; do
8107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8108     ac_cv_prog_STRIP="${ncn_progname}"
8109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8110     break 2
8111   fi
8112 done
8113 done
8114
8115 fi
8116 fi
8117 STRIP=$ac_cv_prog_STRIP
8118 if test -n "$STRIP"; then
8119   echo "$as_me:$LINENO: result: $STRIP" >&5
8120 echo "${ECHO_T}$STRIP" >&6
8121 else
8122   echo "$as_me:$LINENO: result: no" >&5
8123 echo "${ECHO_T}no" >&6
8124 fi
8125
8126   done
8127 fi
8128
8129 for ncn_progname in strip; do
8130   if test -n "$ncn_tool_prefix"; then
8131     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8132 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8133 echo "$as_me:$LINENO: checking for $ac_word" >&5
8134 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8135 if test "${ac_cv_prog_STRIP+set}" = set; then
8136   echo $ECHO_N "(cached) $ECHO_C" >&6
8137 else
8138   if test -n "$STRIP"; then
8139   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8140 else
8141 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8142 for as_dir in $PATH
8143 do
8144   IFS=$as_save_IFS
8145   test -z "$as_dir" && as_dir=.
8146   for ac_exec_ext in '' $ac_executable_extensions; do
8147   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8148     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8150     break 2
8151   fi
8152 done
8153 done
8154
8155 fi
8156 fi
8157 STRIP=$ac_cv_prog_STRIP
8158 if test -n "$STRIP"; then
8159   echo "$as_me:$LINENO: result: $STRIP" >&5
8160 echo "${ECHO_T}$STRIP" >&6
8161 else
8162   echo "$as_me:$LINENO: result: no" >&5
8163 echo "${ECHO_T}no" >&6
8164 fi
8165
8166   fi
8167   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8168     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8169 set dummy ${ncn_progname}; ac_word=$2
8170 echo "$as_me:$LINENO: checking for $ac_word" >&5
8171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8172 if test "${ac_cv_prog_STRIP+set}" = set; then
8173   echo $ECHO_N "(cached) $ECHO_C" >&6
8174 else
8175   if test -n "$STRIP"; then
8176   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8177 else
8178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8179 for as_dir in $PATH
8180 do
8181   IFS=$as_save_IFS
8182   test -z "$as_dir" && as_dir=.
8183   for ac_exec_ext in '' $ac_executable_extensions; do
8184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8185     ac_cv_prog_STRIP="${ncn_progname}"
8186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8187     break 2
8188   fi
8189 done
8190 done
8191
8192 fi
8193 fi
8194 STRIP=$ac_cv_prog_STRIP
8195 if test -n "$STRIP"; then
8196   echo "$as_me:$LINENO: result: $STRIP" >&5
8197 echo "${ECHO_T}$STRIP" >&6
8198 else
8199   echo "$as_me:$LINENO: result: no" >&5
8200 echo "${ECHO_T}no" >&6
8201 fi
8202
8203   fi
8204   test -n "$ac_cv_prog_STRIP" && break
8205 done
8206
8207 if test -z "$ac_cv_prog_STRIP" ; then
8208   STRIP=":"
8209 fi
8210
8211
8212
8213 if test -n "$WINDRES"; then
8214   ac_cv_prog_WINDRES=$WINDRES
8215 elif test -n "$ac_cv_prog_WINDRES"; then
8216   WINDRES=$ac_cv_prog_WINDRES
8217 fi
8218
8219 if test -n "$ac_cv_prog_WINDRES"; then
8220   for ncn_progname in windres; do
8221     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8222 set dummy ${ncn_progname}; ac_word=$2
8223 echo "$as_me:$LINENO: checking for $ac_word" >&5
8224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8225 if test "${ac_cv_prog_WINDRES+set}" = set; then
8226   echo $ECHO_N "(cached) $ECHO_C" >&6
8227 else
8228   if test -n "$WINDRES"; then
8229   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8230 else
8231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8232 for as_dir in $PATH
8233 do
8234   IFS=$as_save_IFS
8235   test -z "$as_dir" && as_dir=.
8236   for ac_exec_ext in '' $ac_executable_extensions; do
8237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8238     ac_cv_prog_WINDRES="${ncn_progname}"
8239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8240     break 2
8241   fi
8242 done
8243 done
8244
8245 fi
8246 fi
8247 WINDRES=$ac_cv_prog_WINDRES
8248 if test -n "$WINDRES"; then
8249   echo "$as_me:$LINENO: result: $WINDRES" >&5
8250 echo "${ECHO_T}$WINDRES" >&6
8251 else
8252   echo "$as_me:$LINENO: result: no" >&5
8253 echo "${ECHO_T}no" >&6
8254 fi
8255
8256   done
8257 fi
8258
8259 for ncn_progname in windres; do
8260   if test -n "$ncn_tool_prefix"; then
8261     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8262 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8263 echo "$as_me:$LINENO: checking for $ac_word" >&5
8264 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8265 if test "${ac_cv_prog_WINDRES+set}" = set; then
8266   echo $ECHO_N "(cached) $ECHO_C" >&6
8267 else
8268   if test -n "$WINDRES"; then
8269   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8270 else
8271 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8272 for as_dir in $PATH
8273 do
8274   IFS=$as_save_IFS
8275   test -z "$as_dir" && as_dir=.
8276   for ac_exec_ext in '' $ac_executable_extensions; do
8277   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8278     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8279     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8280     break 2
8281   fi
8282 done
8283 done
8284
8285 fi
8286 fi
8287 WINDRES=$ac_cv_prog_WINDRES
8288 if test -n "$WINDRES"; then
8289   echo "$as_me:$LINENO: result: $WINDRES" >&5
8290 echo "${ECHO_T}$WINDRES" >&6
8291 else
8292   echo "$as_me:$LINENO: result: no" >&5
8293 echo "${ECHO_T}no" >&6
8294 fi
8295
8296   fi
8297   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8298     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8299 set dummy ${ncn_progname}; ac_word=$2
8300 echo "$as_me:$LINENO: checking for $ac_word" >&5
8301 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8302 if test "${ac_cv_prog_WINDRES+set}" = set; then
8303   echo $ECHO_N "(cached) $ECHO_C" >&6
8304 else
8305   if test -n "$WINDRES"; then
8306   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8307 else
8308 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8309 for as_dir in $PATH
8310 do
8311   IFS=$as_save_IFS
8312   test -z "$as_dir" && as_dir=.
8313   for ac_exec_ext in '' $ac_executable_extensions; do
8314   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8315     ac_cv_prog_WINDRES="${ncn_progname}"
8316     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8317     break 2
8318   fi
8319 done
8320 done
8321
8322 fi
8323 fi
8324 WINDRES=$ac_cv_prog_WINDRES
8325 if test -n "$WINDRES"; then
8326   echo "$as_me:$LINENO: result: $WINDRES" >&5
8327 echo "${ECHO_T}$WINDRES" >&6
8328 else
8329   echo "$as_me:$LINENO: result: no" >&5
8330 echo "${ECHO_T}no" >&6
8331 fi
8332
8333   fi
8334   test -n "$ac_cv_prog_WINDRES" && break
8335 done
8336
8337 if test -z "$ac_cv_prog_WINDRES" ; then
8338   set dummy windres
8339   if test $build = $host ; then
8340     WINDRES="$2"
8341   else
8342     WINDRES="${ncn_tool_prefix}$2"
8343   fi
8344 fi
8345
8346
8347
8348 if test -n "$WINDMC"; then
8349   ac_cv_prog_WINDMC=$WINDMC
8350 elif test -n "$ac_cv_prog_WINDMC"; then
8351   WINDMC=$ac_cv_prog_WINDMC
8352 fi
8353
8354 if test -n "$ac_cv_prog_WINDMC"; then
8355   for ncn_progname in windmc; do
8356     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8357 set dummy ${ncn_progname}; ac_word=$2
8358 echo "$as_me:$LINENO: checking for $ac_word" >&5
8359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8360 if test "${ac_cv_prog_WINDMC+set}" = set; then
8361   echo $ECHO_N "(cached) $ECHO_C" >&6
8362 else
8363   if test -n "$WINDMC"; then
8364   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8365 else
8366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8367 for as_dir in $PATH
8368 do
8369   IFS=$as_save_IFS
8370   test -z "$as_dir" && as_dir=.
8371   for ac_exec_ext in '' $ac_executable_extensions; do
8372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8373     ac_cv_prog_WINDMC="${ncn_progname}"
8374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8375     break 2
8376   fi
8377 done
8378 done
8379
8380 fi
8381 fi
8382 WINDMC=$ac_cv_prog_WINDMC
8383 if test -n "$WINDMC"; then
8384   echo "$as_me:$LINENO: result: $WINDMC" >&5
8385 echo "${ECHO_T}$WINDMC" >&6
8386 else
8387   echo "$as_me:$LINENO: result: no" >&5
8388 echo "${ECHO_T}no" >&6
8389 fi
8390
8391   done
8392 fi
8393
8394 for ncn_progname in windmc; do
8395   if test -n "$ncn_tool_prefix"; then
8396     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8397 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8398 echo "$as_me:$LINENO: checking for $ac_word" >&5
8399 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8400 if test "${ac_cv_prog_WINDMC+set}" = set; then
8401   echo $ECHO_N "(cached) $ECHO_C" >&6
8402 else
8403   if test -n "$WINDMC"; then
8404   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8405 else
8406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8407 for as_dir in $PATH
8408 do
8409   IFS=$as_save_IFS
8410   test -z "$as_dir" && as_dir=.
8411   for ac_exec_ext in '' $ac_executable_extensions; do
8412   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8413     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8414     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8415     break 2
8416   fi
8417 done
8418 done
8419
8420 fi
8421 fi
8422 WINDMC=$ac_cv_prog_WINDMC
8423 if test -n "$WINDMC"; then
8424   echo "$as_me:$LINENO: result: $WINDMC" >&5
8425 echo "${ECHO_T}$WINDMC" >&6
8426 else
8427   echo "$as_me:$LINENO: result: no" >&5
8428 echo "${ECHO_T}no" >&6
8429 fi
8430
8431   fi
8432   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8433     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8434 set dummy ${ncn_progname}; ac_word=$2
8435 echo "$as_me:$LINENO: checking for $ac_word" >&5
8436 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8437 if test "${ac_cv_prog_WINDMC+set}" = set; then
8438   echo $ECHO_N "(cached) $ECHO_C" >&6
8439 else
8440   if test -n "$WINDMC"; then
8441   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8442 else
8443 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8444 for as_dir in $PATH
8445 do
8446   IFS=$as_save_IFS
8447   test -z "$as_dir" && as_dir=.
8448   for ac_exec_ext in '' $ac_executable_extensions; do
8449   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8450     ac_cv_prog_WINDMC="${ncn_progname}"
8451     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8452     break 2
8453   fi
8454 done
8455 done
8456
8457 fi
8458 fi
8459 WINDMC=$ac_cv_prog_WINDMC
8460 if test -n "$WINDMC"; then
8461   echo "$as_me:$LINENO: result: $WINDMC" >&5
8462 echo "${ECHO_T}$WINDMC" >&6
8463 else
8464   echo "$as_me:$LINENO: result: no" >&5
8465 echo "${ECHO_T}no" >&6
8466 fi
8467
8468   fi
8469   test -n "$ac_cv_prog_WINDMC" && break
8470 done
8471
8472 if test -z "$ac_cv_prog_WINDMC" ; then
8473   set dummy windmc
8474   if test $build = $host ; then
8475     WINDMC="$2"
8476   else
8477     WINDMC="${ncn_tool_prefix}$2"
8478   fi
8479 fi
8480
8481
8482
8483 if test -n "$OBJCOPY"; then
8484   ac_cv_prog_OBJCOPY=$OBJCOPY
8485 elif test -n "$ac_cv_prog_OBJCOPY"; then
8486   OBJCOPY=$ac_cv_prog_OBJCOPY
8487 fi
8488
8489 if test -n "$ac_cv_prog_OBJCOPY"; then
8490   for ncn_progname in objcopy; do
8491     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8492 set dummy ${ncn_progname}; ac_word=$2
8493 echo "$as_me:$LINENO: checking for $ac_word" >&5
8494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8495 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8496   echo $ECHO_N "(cached) $ECHO_C" >&6
8497 else
8498   if test -n "$OBJCOPY"; then
8499   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8500 else
8501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8502 for as_dir in $PATH
8503 do
8504   IFS=$as_save_IFS
8505   test -z "$as_dir" && as_dir=.
8506   for ac_exec_ext in '' $ac_executable_extensions; do
8507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8508     ac_cv_prog_OBJCOPY="${ncn_progname}"
8509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8510     break 2
8511   fi
8512 done
8513 done
8514
8515 fi
8516 fi
8517 OBJCOPY=$ac_cv_prog_OBJCOPY
8518 if test -n "$OBJCOPY"; then
8519   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8520 echo "${ECHO_T}$OBJCOPY" >&6
8521 else
8522   echo "$as_me:$LINENO: result: no" >&5
8523 echo "${ECHO_T}no" >&6
8524 fi
8525
8526   done
8527 fi
8528
8529 for ncn_progname in objcopy; do
8530   if test -n "$ncn_tool_prefix"; then
8531     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8532 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8533 echo "$as_me:$LINENO: checking for $ac_word" >&5
8534 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8535 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8536   echo $ECHO_N "(cached) $ECHO_C" >&6
8537 else
8538   if test -n "$OBJCOPY"; then
8539   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8540 else
8541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8542 for as_dir in $PATH
8543 do
8544   IFS=$as_save_IFS
8545   test -z "$as_dir" && as_dir=.
8546   for ac_exec_ext in '' $ac_executable_extensions; do
8547   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8548     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8549     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8550     break 2
8551   fi
8552 done
8553 done
8554
8555 fi
8556 fi
8557 OBJCOPY=$ac_cv_prog_OBJCOPY
8558 if test -n "$OBJCOPY"; then
8559   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8560 echo "${ECHO_T}$OBJCOPY" >&6
8561 else
8562   echo "$as_me:$LINENO: result: no" >&5
8563 echo "${ECHO_T}no" >&6
8564 fi
8565
8566   fi
8567   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8568     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8569 set dummy ${ncn_progname}; ac_word=$2
8570 echo "$as_me:$LINENO: checking for $ac_word" >&5
8571 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8572 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8573   echo $ECHO_N "(cached) $ECHO_C" >&6
8574 else
8575   if test -n "$OBJCOPY"; then
8576   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8577 else
8578 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8579 for as_dir in $PATH
8580 do
8581   IFS=$as_save_IFS
8582   test -z "$as_dir" && as_dir=.
8583   for ac_exec_ext in '' $ac_executable_extensions; do
8584   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8585     ac_cv_prog_OBJCOPY="${ncn_progname}"
8586     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8587     break 2
8588   fi
8589 done
8590 done
8591
8592 fi
8593 fi
8594 OBJCOPY=$ac_cv_prog_OBJCOPY
8595 if test -n "$OBJCOPY"; then
8596   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8597 echo "${ECHO_T}$OBJCOPY" >&6
8598 else
8599   echo "$as_me:$LINENO: result: no" >&5
8600 echo "${ECHO_T}no" >&6
8601 fi
8602
8603   fi
8604   test -n "$ac_cv_prog_OBJCOPY" && break
8605 done
8606
8607 if test -z "$ac_cv_prog_OBJCOPY" ; then
8608   set dummy objcopy
8609   if test $build = $host ; then
8610     OBJCOPY="$2"
8611   else
8612     OBJCOPY="${ncn_tool_prefix}$2"
8613   fi
8614 fi
8615
8616
8617
8618 if test -n "$OBJDUMP"; then
8619   ac_cv_prog_OBJDUMP=$OBJDUMP
8620 elif test -n "$ac_cv_prog_OBJDUMP"; then
8621   OBJDUMP=$ac_cv_prog_OBJDUMP
8622 fi
8623
8624 if test -n "$ac_cv_prog_OBJDUMP"; then
8625   for ncn_progname in objdump; do
8626     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8627 set dummy ${ncn_progname}; ac_word=$2
8628 echo "$as_me:$LINENO: checking for $ac_word" >&5
8629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8630 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8631   echo $ECHO_N "(cached) $ECHO_C" >&6
8632 else
8633   if test -n "$OBJDUMP"; then
8634   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8635 else
8636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8637 for as_dir in $PATH
8638 do
8639   IFS=$as_save_IFS
8640   test -z "$as_dir" && as_dir=.
8641   for ac_exec_ext in '' $ac_executable_extensions; do
8642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8643     ac_cv_prog_OBJDUMP="${ncn_progname}"
8644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8645     break 2
8646   fi
8647 done
8648 done
8649
8650 fi
8651 fi
8652 OBJDUMP=$ac_cv_prog_OBJDUMP
8653 if test -n "$OBJDUMP"; then
8654   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8655 echo "${ECHO_T}$OBJDUMP" >&6
8656 else
8657   echo "$as_me:$LINENO: result: no" >&5
8658 echo "${ECHO_T}no" >&6
8659 fi
8660
8661   done
8662 fi
8663
8664 for ncn_progname in objdump; do
8665   if test -n "$ncn_tool_prefix"; then
8666     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8667 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8668 echo "$as_me:$LINENO: checking for $ac_word" >&5
8669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8670 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8671   echo $ECHO_N "(cached) $ECHO_C" >&6
8672 else
8673   if test -n "$OBJDUMP"; then
8674   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8675 else
8676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8677 for as_dir in $PATH
8678 do
8679   IFS=$as_save_IFS
8680   test -z "$as_dir" && as_dir=.
8681   for ac_exec_ext in '' $ac_executable_extensions; do
8682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8683     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8685     break 2
8686   fi
8687 done
8688 done
8689
8690 fi
8691 fi
8692 OBJDUMP=$ac_cv_prog_OBJDUMP
8693 if test -n "$OBJDUMP"; then
8694   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8695 echo "${ECHO_T}$OBJDUMP" >&6
8696 else
8697   echo "$as_me:$LINENO: result: no" >&5
8698 echo "${ECHO_T}no" >&6
8699 fi
8700
8701   fi
8702   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8703     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8704 set dummy ${ncn_progname}; ac_word=$2
8705 echo "$as_me:$LINENO: checking for $ac_word" >&5
8706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8707 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8708   echo $ECHO_N "(cached) $ECHO_C" >&6
8709 else
8710   if test -n "$OBJDUMP"; then
8711   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8712 else
8713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8714 for as_dir in $PATH
8715 do
8716   IFS=$as_save_IFS
8717   test -z "$as_dir" && as_dir=.
8718   for ac_exec_ext in '' $ac_executable_extensions; do
8719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8720     ac_cv_prog_OBJDUMP="${ncn_progname}"
8721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8722     break 2
8723   fi
8724 done
8725 done
8726
8727 fi
8728 fi
8729 OBJDUMP=$ac_cv_prog_OBJDUMP
8730 if test -n "$OBJDUMP"; then
8731   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8732 echo "${ECHO_T}$OBJDUMP" >&6
8733 else
8734   echo "$as_me:$LINENO: result: no" >&5
8735 echo "${ECHO_T}no" >&6
8736 fi
8737
8738   fi
8739   test -n "$ac_cv_prog_OBJDUMP" && break
8740 done
8741
8742 if test -z "$ac_cv_prog_OBJDUMP" ; then
8743   set dummy objdump
8744   if test $build = $host ; then
8745     OBJDUMP="$2"
8746   else
8747     OBJDUMP="${ncn_tool_prefix}$2"
8748   fi
8749 fi
8750
8751
8752
8753
8754
8755
8756 # Target tools.
8757
8758 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8759 if test "${with_build_time_tools+set}" = set; then
8760   withval="$with_build_time_tools"
8761   case x"$withval" in
8762      x/*) ;;
8763      *)
8764        with_build_time_tools=
8765        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8766 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8767        ;;
8768    esac
8769 else
8770   with_build_time_tools=
8771 fi;
8772
8773
8774
8775 if test -n "$CC_FOR_TARGET"; then
8776   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8777 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8778   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8779 fi
8780
8781 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8782   for ncn_progname in cc gcc; do
8783     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8784 set dummy ${ncn_progname}; ac_word=$2
8785 echo "$as_me:$LINENO: checking for $ac_word" >&5
8786 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8787 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8788   echo $ECHO_N "(cached) $ECHO_C" >&6
8789 else
8790   if test -n "$CC_FOR_TARGET"; then
8791   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8792 else
8793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8794 for as_dir in $PATH
8795 do
8796   IFS=$as_save_IFS
8797   test -z "$as_dir" && as_dir=.
8798   for ac_exec_ext in '' $ac_executable_extensions; do
8799   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8800     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8801     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8802     break 2
8803   fi
8804 done
8805 done
8806
8807 fi
8808 fi
8809 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8810 if test -n "$CC_FOR_TARGET"; then
8811   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8812 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8813 else
8814   echo "$as_me:$LINENO: result: no" >&5
8815 echo "${ECHO_T}no" >&6
8816 fi
8817
8818   done
8819 fi
8820
8821 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8822   for ncn_progname in cc gcc; do
8823     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8824 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8825     if test -x $with_build_time_tools/${ncn_progname}; then
8826       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8827       echo "$as_me:$LINENO: result: yes" >&5
8828 echo "${ECHO_T}yes" >&6
8829       break
8830     else
8831       echo "$as_me:$LINENO: result: no" >&5
8832 echo "${ECHO_T}no" >&6
8833     fi
8834   done
8835 fi
8836
8837 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8838   for ncn_progname in cc gcc; do
8839     if test -n "$ncn_target_tool_prefix"; then
8840       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8841 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8842 echo "$as_me:$LINENO: checking for $ac_word" >&5
8843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8844 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8845   echo $ECHO_N "(cached) $ECHO_C" >&6
8846 else
8847   if test -n "$CC_FOR_TARGET"; then
8848   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8849 else
8850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8851 for as_dir in $PATH
8852 do
8853   IFS=$as_save_IFS
8854   test -z "$as_dir" && as_dir=.
8855   for ac_exec_ext in '' $ac_executable_extensions; do
8856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8857     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8859     break 2
8860   fi
8861 done
8862 done
8863
8864 fi
8865 fi
8866 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8867 if test -n "$CC_FOR_TARGET"; then
8868   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8869 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8870 else
8871   echo "$as_me:$LINENO: result: no" >&5
8872 echo "${ECHO_T}no" >&6
8873 fi
8874
8875     fi
8876     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8877       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8878 set dummy ${ncn_progname}; ac_word=$2
8879 echo "$as_me:$LINENO: checking for $ac_word" >&5
8880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8881 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8882   echo $ECHO_N "(cached) $ECHO_C" >&6
8883 else
8884   if test -n "$CC_FOR_TARGET"; then
8885   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8886 else
8887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8888 for as_dir in $PATH
8889 do
8890   IFS=$as_save_IFS
8891   test -z "$as_dir" && as_dir=.
8892   for ac_exec_ext in '' $ac_executable_extensions; do
8893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8894     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8896     break 2
8897   fi
8898 done
8899 done
8900
8901 fi
8902 fi
8903 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8904 if test -n "$CC_FOR_TARGET"; then
8905   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8906 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8907 else
8908   echo "$as_me:$LINENO: result: no" >&5
8909 echo "${ECHO_T}no" >&6
8910 fi
8911
8912     fi
8913     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8914   done
8915 fi
8916
8917 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8918   set dummy cc gcc
8919   if test $build = $target ; then
8920     CC_FOR_TARGET="$2"
8921   else
8922     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8923   fi
8924 else
8925   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8926 fi
8927
8928
8929
8930 if test -n "$CXX_FOR_TARGET"; then
8931   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8932 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8933   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8934 fi
8935
8936 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8937   for ncn_progname in c++ g++ cxx gxx; do
8938     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8939 set dummy ${ncn_progname}; ac_word=$2
8940 echo "$as_me:$LINENO: checking for $ac_word" >&5
8941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8942 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8943   echo $ECHO_N "(cached) $ECHO_C" >&6
8944 else
8945   if test -n "$CXX_FOR_TARGET"; then
8946   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8947 else
8948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8949 for as_dir in $PATH
8950 do
8951   IFS=$as_save_IFS
8952   test -z "$as_dir" && as_dir=.
8953   for ac_exec_ext in '' $ac_executable_extensions; do
8954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8955     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8957     break 2
8958   fi
8959 done
8960 done
8961
8962 fi
8963 fi
8964 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8965 if test -n "$CXX_FOR_TARGET"; then
8966   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8967 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8968 else
8969   echo "$as_me:$LINENO: result: no" >&5
8970 echo "${ECHO_T}no" >&6
8971 fi
8972
8973   done
8974 fi
8975
8976 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8977   for ncn_progname in c++ g++ cxx gxx; do
8978     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8979 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8980     if test -x $with_build_time_tools/${ncn_progname}; then
8981       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8982       echo "$as_me:$LINENO: result: yes" >&5
8983 echo "${ECHO_T}yes" >&6
8984       break
8985     else
8986       echo "$as_me:$LINENO: result: no" >&5
8987 echo "${ECHO_T}no" >&6
8988     fi
8989   done
8990 fi
8991
8992 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8993   for ncn_progname in c++ g++ cxx gxx; do
8994     if test -n "$ncn_target_tool_prefix"; then
8995       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8996 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8997 echo "$as_me:$LINENO: checking for $ac_word" >&5
8998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8999 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9000   echo $ECHO_N "(cached) $ECHO_C" >&6
9001 else
9002   if test -n "$CXX_FOR_TARGET"; then
9003   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9004 else
9005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9006 for as_dir in $PATH
9007 do
9008   IFS=$as_save_IFS
9009   test -z "$as_dir" && as_dir=.
9010   for ac_exec_ext in '' $ac_executable_extensions; do
9011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9012     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9014     break 2
9015   fi
9016 done
9017 done
9018
9019 fi
9020 fi
9021 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9022 if test -n "$CXX_FOR_TARGET"; then
9023   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9024 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9025 else
9026   echo "$as_me:$LINENO: result: no" >&5
9027 echo "${ECHO_T}no" >&6
9028 fi
9029
9030     fi
9031     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
9032       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9033 set dummy ${ncn_progname}; ac_word=$2
9034 echo "$as_me:$LINENO: checking for $ac_word" >&5
9035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9036 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9037   echo $ECHO_N "(cached) $ECHO_C" >&6
9038 else
9039   if test -n "$CXX_FOR_TARGET"; then
9040   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9041 else
9042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9043 for as_dir in $PATH
9044 do
9045   IFS=$as_save_IFS
9046   test -z "$as_dir" && as_dir=.
9047   for ac_exec_ext in '' $ac_executable_extensions; do
9048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9049     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
9050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9051     break 2
9052   fi
9053 done
9054 done
9055
9056 fi
9057 fi
9058 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9059 if test -n "$CXX_FOR_TARGET"; then
9060   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9061 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9062 else
9063   echo "$as_me:$LINENO: result: no" >&5
9064 echo "${ECHO_T}no" >&6
9065 fi
9066
9067     fi
9068     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
9069   done
9070 fi
9071
9072 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
9073   set dummy c++ g++ cxx gxx
9074   if test $build = $target ; then
9075     CXX_FOR_TARGET="$2"
9076   else
9077     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
9078   fi
9079 else
9080   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
9081 fi
9082
9083
9084
9085 if test -n "$GCC_FOR_TARGET"; then
9086   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
9087 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9088   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9089 fi
9090
9091 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9092   for ncn_progname in gcc; do
9093     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9094 set dummy ${ncn_progname}; ac_word=$2
9095 echo "$as_me:$LINENO: checking for $ac_word" >&5
9096 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9097 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9098   echo $ECHO_N "(cached) $ECHO_C" >&6
9099 else
9100   if test -n "$GCC_FOR_TARGET"; then
9101   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9102 else
9103 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9104 for as_dir in $PATH
9105 do
9106   IFS=$as_save_IFS
9107   test -z "$as_dir" && as_dir=.
9108   for ac_exec_ext in '' $ac_executable_extensions; do
9109   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9110     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9111     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9112     break 2
9113   fi
9114 done
9115 done
9116
9117 fi
9118 fi
9119 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9120 if test -n "$GCC_FOR_TARGET"; then
9121   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9122 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9123 else
9124   echo "$as_me:$LINENO: result: no" >&5
9125 echo "${ECHO_T}no" >&6
9126 fi
9127
9128   done
9129 fi
9130
9131 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9132   for ncn_progname in gcc; do
9133     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9134 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9135     if test -x $with_build_time_tools/${ncn_progname}; then
9136       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9137       echo "$as_me:$LINENO: result: yes" >&5
9138 echo "${ECHO_T}yes" >&6
9139       break
9140     else
9141       echo "$as_me:$LINENO: result: no" >&5
9142 echo "${ECHO_T}no" >&6
9143     fi
9144   done
9145 fi
9146
9147 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9148   for ncn_progname in gcc; do
9149     if test -n "$ncn_target_tool_prefix"; then
9150       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9151 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9152 echo "$as_me:$LINENO: checking for $ac_word" >&5
9153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9154 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9155   echo $ECHO_N "(cached) $ECHO_C" >&6
9156 else
9157   if test -n "$GCC_FOR_TARGET"; then
9158   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9159 else
9160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9161 for as_dir in $PATH
9162 do
9163   IFS=$as_save_IFS
9164   test -z "$as_dir" && as_dir=.
9165   for ac_exec_ext in '' $ac_executable_extensions; do
9166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9167     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9169     break 2
9170   fi
9171 done
9172 done
9173
9174 fi
9175 fi
9176 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9177 if test -n "$GCC_FOR_TARGET"; then
9178   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9179 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9180 else
9181   echo "$as_me:$LINENO: result: no" >&5
9182 echo "${ECHO_T}no" >&6
9183 fi
9184
9185     fi
9186     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9187       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9188 set dummy ${ncn_progname}; ac_word=$2
9189 echo "$as_me:$LINENO: checking for $ac_word" >&5
9190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9191 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9192   echo $ECHO_N "(cached) $ECHO_C" >&6
9193 else
9194   if test -n "$GCC_FOR_TARGET"; then
9195   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9196 else
9197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9198 for as_dir in $PATH
9199 do
9200   IFS=$as_save_IFS
9201   test -z "$as_dir" && as_dir=.
9202   for ac_exec_ext in '' $ac_executable_extensions; do
9203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9204     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9206     break 2
9207   fi
9208 done
9209 done
9210
9211 fi
9212 fi
9213 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9214 if test -n "$GCC_FOR_TARGET"; then
9215   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9216 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9217 else
9218   echo "$as_me:$LINENO: result: no" >&5
9219 echo "${ECHO_T}no" >&6
9220 fi
9221
9222     fi
9223     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9224   done
9225 fi
9226
9227 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9228   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9229 else
9230   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9231 fi
9232
9233
9234
9235 if test -n "$GCJ_FOR_TARGET"; then
9236   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9237 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9238   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9239 fi
9240
9241 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9242   for ncn_progname in gcj; do
9243     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9244 set dummy ${ncn_progname}; ac_word=$2
9245 echo "$as_me:$LINENO: checking for $ac_word" >&5
9246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9247 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9248   echo $ECHO_N "(cached) $ECHO_C" >&6
9249 else
9250   if test -n "$GCJ_FOR_TARGET"; then
9251   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9252 else
9253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9254 for as_dir in $PATH
9255 do
9256   IFS=$as_save_IFS
9257   test -z "$as_dir" && as_dir=.
9258   for ac_exec_ext in '' $ac_executable_extensions; do
9259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9260     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9262     break 2
9263   fi
9264 done
9265 done
9266
9267 fi
9268 fi
9269 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9270 if test -n "$GCJ_FOR_TARGET"; then
9271   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9272 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9273 else
9274   echo "$as_me:$LINENO: result: no" >&5
9275 echo "${ECHO_T}no" >&6
9276 fi
9277
9278   done
9279 fi
9280
9281 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9282   for ncn_progname in gcj; do
9283     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9284 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9285     if test -x $with_build_time_tools/${ncn_progname}; then
9286       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9287       echo "$as_me:$LINENO: result: yes" >&5
9288 echo "${ECHO_T}yes" >&6
9289       break
9290     else
9291       echo "$as_me:$LINENO: result: no" >&5
9292 echo "${ECHO_T}no" >&6
9293     fi
9294   done
9295 fi
9296
9297 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9298   for ncn_progname in gcj; do
9299     if test -n "$ncn_target_tool_prefix"; then
9300       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9301 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9302 echo "$as_me:$LINENO: checking for $ac_word" >&5
9303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9304 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9305   echo $ECHO_N "(cached) $ECHO_C" >&6
9306 else
9307   if test -n "$GCJ_FOR_TARGET"; then
9308   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9309 else
9310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9311 for as_dir in $PATH
9312 do
9313   IFS=$as_save_IFS
9314   test -z "$as_dir" && as_dir=.
9315   for ac_exec_ext in '' $ac_executable_extensions; do
9316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9317     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9319     break 2
9320   fi
9321 done
9322 done
9323
9324 fi
9325 fi
9326 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9327 if test -n "$GCJ_FOR_TARGET"; then
9328   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9329 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9330 else
9331   echo "$as_me:$LINENO: result: no" >&5
9332 echo "${ECHO_T}no" >&6
9333 fi
9334
9335     fi
9336     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9337       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9338 set dummy ${ncn_progname}; ac_word=$2
9339 echo "$as_me:$LINENO: checking for $ac_word" >&5
9340 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9341 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9342   echo $ECHO_N "(cached) $ECHO_C" >&6
9343 else
9344   if test -n "$GCJ_FOR_TARGET"; then
9345   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9346 else
9347 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9348 for as_dir in $PATH
9349 do
9350   IFS=$as_save_IFS
9351   test -z "$as_dir" && as_dir=.
9352   for ac_exec_ext in '' $ac_executable_extensions; do
9353   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9354     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9355     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9356     break 2
9357   fi
9358 done
9359 done
9360
9361 fi
9362 fi
9363 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9364 if test -n "$GCJ_FOR_TARGET"; then
9365   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9366 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9367 else
9368   echo "$as_me:$LINENO: result: no" >&5
9369 echo "${ECHO_T}no" >&6
9370 fi
9371
9372     fi
9373     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9374   done
9375 fi
9376
9377 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9378   set dummy gcj
9379   if test $build = $target ; then
9380     GCJ_FOR_TARGET="$2"
9381   else
9382     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9383   fi
9384 else
9385   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9386 fi
9387
9388
9389
9390 if test -n "$GFORTRAN_FOR_TARGET"; then
9391   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9392 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9393   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9394 fi
9395
9396 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9397   for ncn_progname in gfortran; do
9398     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9399 set dummy ${ncn_progname}; ac_word=$2
9400 echo "$as_me:$LINENO: checking for $ac_word" >&5
9401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9402 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9403   echo $ECHO_N "(cached) $ECHO_C" >&6
9404 else
9405   if test -n "$GFORTRAN_FOR_TARGET"; then
9406   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9407 else
9408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9409 for as_dir in $PATH
9410 do
9411   IFS=$as_save_IFS
9412   test -z "$as_dir" && as_dir=.
9413   for ac_exec_ext in '' $ac_executable_extensions; do
9414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9415     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9417     break 2
9418   fi
9419 done
9420 done
9421
9422 fi
9423 fi
9424 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9425 if test -n "$GFORTRAN_FOR_TARGET"; then
9426   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9427 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9428 else
9429   echo "$as_me:$LINENO: result: no" >&5
9430 echo "${ECHO_T}no" >&6
9431 fi
9432
9433   done
9434 fi
9435
9436 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9437   for ncn_progname in gfortran; do
9438     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9439 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9440     if test -x $with_build_time_tools/${ncn_progname}; then
9441       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9442       echo "$as_me:$LINENO: result: yes" >&5
9443 echo "${ECHO_T}yes" >&6
9444       break
9445     else
9446       echo "$as_me:$LINENO: result: no" >&5
9447 echo "${ECHO_T}no" >&6
9448     fi
9449   done
9450 fi
9451
9452 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9453   for ncn_progname in gfortran; do
9454     if test -n "$ncn_target_tool_prefix"; then
9455       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9456 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9457 echo "$as_me:$LINENO: checking for $ac_word" >&5
9458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9459 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9460   echo $ECHO_N "(cached) $ECHO_C" >&6
9461 else
9462   if test -n "$GFORTRAN_FOR_TARGET"; then
9463   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9464 else
9465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9466 for as_dir in $PATH
9467 do
9468   IFS=$as_save_IFS
9469   test -z "$as_dir" && as_dir=.
9470   for ac_exec_ext in '' $ac_executable_extensions; do
9471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9472     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9474     break 2
9475   fi
9476 done
9477 done
9478
9479 fi
9480 fi
9481 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9482 if test -n "$GFORTRAN_FOR_TARGET"; then
9483   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9484 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9485 else
9486   echo "$as_me:$LINENO: result: no" >&5
9487 echo "${ECHO_T}no" >&6
9488 fi
9489
9490     fi
9491     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9492       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9493 set dummy ${ncn_progname}; ac_word=$2
9494 echo "$as_me:$LINENO: checking for $ac_word" >&5
9495 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9496 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9497   echo $ECHO_N "(cached) $ECHO_C" >&6
9498 else
9499   if test -n "$GFORTRAN_FOR_TARGET"; then
9500   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9501 else
9502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9503 for as_dir in $PATH
9504 do
9505   IFS=$as_save_IFS
9506   test -z "$as_dir" && as_dir=.
9507   for ac_exec_ext in '' $ac_executable_extensions; do
9508   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9509     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9510     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9511     break 2
9512   fi
9513 done
9514 done
9515
9516 fi
9517 fi
9518 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9519 if test -n "$GFORTRAN_FOR_TARGET"; then
9520   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9521 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9522 else
9523   echo "$as_me:$LINENO: result: no" >&5
9524 echo "${ECHO_T}no" >&6
9525 fi
9526
9527     fi
9528     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9529   done
9530 fi
9531
9532 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9533   set dummy gfortran
9534   if test $build = $target ; then
9535     GFORTRAN_FOR_TARGET="$2"
9536   else
9537     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9538   fi
9539 else
9540   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9541 fi
9542
9543
9544
9545 cat > conftest.c << \EOF
9546 #ifdef __GNUC__
9547   gcc_yay;
9548 #endif
9549 EOF
9550 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9551   have_gcc_for_target=yes
9552 else
9553   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9554   have_gcc_for_target=no
9555 fi
9556 rm conftest.c
9557
9558
9559
9560
9561 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9562   if test -n "$with_build_time_tools"; then
9563     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9564 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9565     if test -x $with_build_time_tools/ar; then
9566       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9567       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9568       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9569 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9570     else
9571       echo "$as_me:$LINENO: result: no" >&5
9572 echo "${ECHO_T}no" >&6
9573     fi
9574   elif test $build != $host && test $have_gcc_for_target = yes; then
9575     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9576     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9577     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9578   fi
9579 fi
9580 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9581   # Extract the first word of "ar", so it can be a program name with args.
9582 set dummy ar; ac_word=$2
9583 echo "$as_me:$LINENO: checking for $ac_word" >&5
9584 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9585 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9586   echo $ECHO_N "(cached) $ECHO_C" >&6
9587 else
9588   case $AR_FOR_TARGET in
9589   [\\/]* | ?:[\\/]*)
9590   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9591   ;;
9592   *)
9593   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9594 for as_dir in $gcc_cv_tool_dirs
9595 do
9596   IFS=$as_save_IFS
9597   test -z "$as_dir" && as_dir=.
9598   for ac_exec_ext in '' $ac_executable_extensions; do
9599   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9600     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9601     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9602     break 2
9603   fi
9604 done
9605 done
9606
9607   ;;
9608 esac
9609 fi
9610 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9611
9612 if test -n "$AR_FOR_TARGET"; then
9613   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9614 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9615 else
9616   echo "$as_me:$LINENO: result: no" >&5
9617 echo "${ECHO_T}no" >&6
9618 fi
9619
9620 fi
9621 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9622
9623
9624 if test -n "$AR_FOR_TARGET"; then
9625   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9626 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9627   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9628 fi
9629
9630 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9631   for ncn_progname in ar; do
9632     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9633 set dummy ${ncn_progname}; ac_word=$2
9634 echo "$as_me:$LINENO: checking for $ac_word" >&5
9635 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9636 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9637   echo $ECHO_N "(cached) $ECHO_C" >&6
9638 else
9639   if test -n "$AR_FOR_TARGET"; then
9640   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9641 else
9642 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9643 for as_dir in $PATH
9644 do
9645   IFS=$as_save_IFS
9646   test -z "$as_dir" && as_dir=.
9647   for ac_exec_ext in '' $ac_executable_extensions; do
9648   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9649     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9650     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9651     break 2
9652   fi
9653 done
9654 done
9655
9656 fi
9657 fi
9658 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9659 if test -n "$AR_FOR_TARGET"; then
9660   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9661 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9662 else
9663   echo "$as_me:$LINENO: result: no" >&5
9664 echo "${ECHO_T}no" >&6
9665 fi
9666
9667   done
9668 fi
9669
9670 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9671   for ncn_progname in ar; do
9672     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9673 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9674     if test -x $with_build_time_tools/${ncn_progname}; then
9675       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9676       echo "$as_me:$LINENO: result: yes" >&5
9677 echo "${ECHO_T}yes" >&6
9678       break
9679     else
9680       echo "$as_me:$LINENO: result: no" >&5
9681 echo "${ECHO_T}no" >&6
9682     fi
9683   done
9684 fi
9685
9686 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9687   for ncn_progname in ar; do
9688     if test -n "$ncn_target_tool_prefix"; then
9689       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9690 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9691 echo "$as_me:$LINENO: checking for $ac_word" >&5
9692 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9693 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9694   echo $ECHO_N "(cached) $ECHO_C" >&6
9695 else
9696   if test -n "$AR_FOR_TARGET"; then
9697   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9698 else
9699 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9700 for as_dir in $PATH
9701 do
9702   IFS=$as_save_IFS
9703   test -z "$as_dir" && as_dir=.
9704   for ac_exec_ext in '' $ac_executable_extensions; do
9705   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9706     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9707     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9708     break 2
9709   fi
9710 done
9711 done
9712
9713 fi
9714 fi
9715 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9716 if test -n "$AR_FOR_TARGET"; then
9717   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9718 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9719 else
9720   echo "$as_me:$LINENO: result: no" >&5
9721 echo "${ECHO_T}no" >&6
9722 fi
9723
9724     fi
9725     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9726       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9727 set dummy ${ncn_progname}; ac_word=$2
9728 echo "$as_me:$LINENO: checking for $ac_word" >&5
9729 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9730 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9731   echo $ECHO_N "(cached) $ECHO_C" >&6
9732 else
9733   if test -n "$AR_FOR_TARGET"; then
9734   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9735 else
9736 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9737 for as_dir in $PATH
9738 do
9739   IFS=$as_save_IFS
9740   test -z "$as_dir" && as_dir=.
9741   for ac_exec_ext in '' $ac_executable_extensions; do
9742   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9743     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9744     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9745     break 2
9746   fi
9747 done
9748 done
9749
9750 fi
9751 fi
9752 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9753 if test -n "$AR_FOR_TARGET"; then
9754   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9755 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9756 else
9757   echo "$as_me:$LINENO: result: no" >&5
9758 echo "${ECHO_T}no" >&6
9759 fi
9760
9761     fi
9762     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9763   done
9764 fi
9765
9766 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9767   set dummy ar
9768   if test $build = $target ; then
9769     AR_FOR_TARGET="$2"
9770   else
9771     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9772   fi
9773 else
9774   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9775 fi
9776
9777 else
9778   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9779 fi
9780
9781
9782
9783
9784 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9785   if test -n "$with_build_time_tools"; then
9786     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9787 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9788     if test -x $with_build_time_tools/as; then
9789       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9790       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9791       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9792 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9793     else
9794       echo "$as_me:$LINENO: result: no" >&5
9795 echo "${ECHO_T}no" >&6
9796     fi
9797   elif test $build != $host && test $have_gcc_for_target = yes; then
9798     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9799     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9800     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9801   fi
9802 fi
9803 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9804   # Extract the first word of "as", so it can be a program name with args.
9805 set dummy as; ac_word=$2
9806 echo "$as_me:$LINENO: checking for $ac_word" >&5
9807 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9808 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9809   echo $ECHO_N "(cached) $ECHO_C" >&6
9810 else
9811   case $AS_FOR_TARGET in
9812   [\\/]* | ?:[\\/]*)
9813   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9814   ;;
9815   *)
9816   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9817 for as_dir in $gcc_cv_tool_dirs
9818 do
9819   IFS=$as_save_IFS
9820   test -z "$as_dir" && as_dir=.
9821   for ac_exec_ext in '' $ac_executable_extensions; do
9822   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9823     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9824     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9825     break 2
9826   fi
9827 done
9828 done
9829
9830   ;;
9831 esac
9832 fi
9833 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9834
9835 if test -n "$AS_FOR_TARGET"; then
9836   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9837 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9838 else
9839   echo "$as_me:$LINENO: result: no" >&5
9840 echo "${ECHO_T}no" >&6
9841 fi
9842
9843 fi
9844 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9845
9846
9847 if test -n "$AS_FOR_TARGET"; then
9848   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9849 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9850   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9851 fi
9852
9853 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9854   for ncn_progname in as; do
9855     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9856 set dummy ${ncn_progname}; ac_word=$2
9857 echo "$as_me:$LINENO: checking for $ac_word" >&5
9858 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9859 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9860   echo $ECHO_N "(cached) $ECHO_C" >&6
9861 else
9862   if test -n "$AS_FOR_TARGET"; then
9863   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9864 else
9865 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9866 for as_dir in $PATH
9867 do
9868   IFS=$as_save_IFS
9869   test -z "$as_dir" && as_dir=.
9870   for ac_exec_ext in '' $ac_executable_extensions; do
9871   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9872     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9873     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9874     break 2
9875   fi
9876 done
9877 done
9878
9879 fi
9880 fi
9881 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9882 if test -n "$AS_FOR_TARGET"; then
9883   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9884 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9885 else
9886   echo "$as_me:$LINENO: result: no" >&5
9887 echo "${ECHO_T}no" >&6
9888 fi
9889
9890   done
9891 fi
9892
9893 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9894   for ncn_progname in as; do
9895     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9896 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9897     if test -x $with_build_time_tools/${ncn_progname}; then
9898       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9899       echo "$as_me:$LINENO: result: yes" >&5
9900 echo "${ECHO_T}yes" >&6
9901       break
9902     else
9903       echo "$as_me:$LINENO: result: no" >&5
9904 echo "${ECHO_T}no" >&6
9905     fi
9906   done
9907 fi
9908
9909 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9910   for ncn_progname in as; do
9911     if test -n "$ncn_target_tool_prefix"; then
9912       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9913 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9914 echo "$as_me:$LINENO: checking for $ac_word" >&5
9915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9916 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9917   echo $ECHO_N "(cached) $ECHO_C" >&6
9918 else
9919   if test -n "$AS_FOR_TARGET"; then
9920   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9921 else
9922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9923 for as_dir in $PATH
9924 do
9925   IFS=$as_save_IFS
9926   test -z "$as_dir" && as_dir=.
9927   for ac_exec_ext in '' $ac_executable_extensions; do
9928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9929     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9931     break 2
9932   fi
9933 done
9934 done
9935
9936 fi
9937 fi
9938 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9939 if test -n "$AS_FOR_TARGET"; then
9940   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9941 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9942 else
9943   echo "$as_me:$LINENO: result: no" >&5
9944 echo "${ECHO_T}no" >&6
9945 fi
9946
9947     fi
9948     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9949       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9950 set dummy ${ncn_progname}; ac_word=$2
9951 echo "$as_me:$LINENO: checking for $ac_word" >&5
9952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9953 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9954   echo $ECHO_N "(cached) $ECHO_C" >&6
9955 else
9956   if test -n "$AS_FOR_TARGET"; then
9957   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9958 else
9959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9960 for as_dir in $PATH
9961 do
9962   IFS=$as_save_IFS
9963   test -z "$as_dir" && as_dir=.
9964   for ac_exec_ext in '' $ac_executable_extensions; do
9965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9966     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9968     break 2
9969   fi
9970 done
9971 done
9972
9973 fi
9974 fi
9975 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9976 if test -n "$AS_FOR_TARGET"; then
9977   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9978 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9979 else
9980   echo "$as_me:$LINENO: result: no" >&5
9981 echo "${ECHO_T}no" >&6
9982 fi
9983
9984     fi
9985     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9986   done
9987 fi
9988
9989 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9990   set dummy as
9991   if test $build = $target ; then
9992     AS_FOR_TARGET="$2"
9993   else
9994     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9995   fi
9996 else
9997   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9998 fi
9999
10000 else
10001   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
10002 fi
10003
10004
10005
10006
10007 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10008   if test -n "$with_build_time_tools"; then
10009     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
10010 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
10011     if test -x $with_build_time_tools/dlltool; then
10012       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
10013       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10014       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
10015 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
10016     else
10017       echo "$as_me:$LINENO: result: no" >&5
10018 echo "${ECHO_T}no" >&6
10019     fi
10020   elif test $build != $host && test $have_gcc_for_target = yes; then
10021     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
10022     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
10023     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10024   fi
10025 fi
10026 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10027   # Extract the first word of "dlltool", so it can be a program name with args.
10028 set dummy dlltool; ac_word=$2
10029 echo "$as_me:$LINENO: checking for $ac_word" >&5
10030 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10031 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
10032   echo $ECHO_N "(cached) $ECHO_C" >&6
10033 else
10034   case $DLLTOOL_FOR_TARGET in
10035   [\\/]* | ?:[\\/]*)
10036   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
10037   ;;
10038   *)
10039   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10040 for as_dir in $gcc_cv_tool_dirs
10041 do
10042   IFS=$as_save_IFS
10043   test -z "$as_dir" && as_dir=.
10044   for ac_exec_ext in '' $ac_executable_extensions; do
10045   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10046     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10047     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10048     break 2
10049   fi
10050 done
10051 done
10052
10053   ;;
10054 esac
10055 fi
10056 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10057
10058 if test -n "$DLLTOOL_FOR_TARGET"; then
10059   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10060 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10061 else
10062   echo "$as_me:$LINENO: result: no" >&5
10063 echo "${ECHO_T}no" >&6
10064 fi
10065
10066 fi
10067 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10068
10069
10070 if test -n "$DLLTOOL_FOR_TARGET"; then
10071   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10072 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10073   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10074 fi
10075
10076 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10077   for ncn_progname in dlltool; do
10078     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10079 set dummy ${ncn_progname}; ac_word=$2
10080 echo "$as_me:$LINENO: checking for $ac_word" >&5
10081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10082 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10083   echo $ECHO_N "(cached) $ECHO_C" >&6
10084 else
10085   if test -n "$DLLTOOL_FOR_TARGET"; then
10086   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10087 else
10088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10089 for as_dir in $PATH
10090 do
10091   IFS=$as_save_IFS
10092   test -z "$as_dir" && as_dir=.
10093   for ac_exec_ext in '' $ac_executable_extensions; do
10094   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10095     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10096     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10097     break 2
10098   fi
10099 done
10100 done
10101
10102 fi
10103 fi
10104 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10105 if test -n "$DLLTOOL_FOR_TARGET"; then
10106   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10107 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10108 else
10109   echo "$as_me:$LINENO: result: no" >&5
10110 echo "${ECHO_T}no" >&6
10111 fi
10112
10113   done
10114 fi
10115
10116 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10117   for ncn_progname in dlltool; do
10118     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10119 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10120     if test -x $with_build_time_tools/${ncn_progname}; then
10121       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10122       echo "$as_me:$LINENO: result: yes" >&5
10123 echo "${ECHO_T}yes" >&6
10124       break
10125     else
10126       echo "$as_me:$LINENO: result: no" >&5
10127 echo "${ECHO_T}no" >&6
10128     fi
10129   done
10130 fi
10131
10132 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10133   for ncn_progname in dlltool; do
10134     if test -n "$ncn_target_tool_prefix"; then
10135       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10136 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10137 echo "$as_me:$LINENO: checking for $ac_word" >&5
10138 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10139 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10140   echo $ECHO_N "(cached) $ECHO_C" >&6
10141 else
10142   if test -n "$DLLTOOL_FOR_TARGET"; then
10143   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10144 else
10145 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10146 for as_dir in $PATH
10147 do
10148   IFS=$as_save_IFS
10149   test -z "$as_dir" && as_dir=.
10150   for ac_exec_ext in '' $ac_executable_extensions; do
10151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10152     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10154     break 2
10155   fi
10156 done
10157 done
10158
10159 fi
10160 fi
10161 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10162 if test -n "$DLLTOOL_FOR_TARGET"; then
10163   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10164 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10165 else
10166   echo "$as_me:$LINENO: result: no" >&5
10167 echo "${ECHO_T}no" >&6
10168 fi
10169
10170     fi
10171     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10172       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10173 set dummy ${ncn_progname}; ac_word=$2
10174 echo "$as_me:$LINENO: checking for $ac_word" >&5
10175 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10176 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10177   echo $ECHO_N "(cached) $ECHO_C" >&6
10178 else
10179   if test -n "$DLLTOOL_FOR_TARGET"; then
10180   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10181 else
10182 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10183 for as_dir in $PATH
10184 do
10185   IFS=$as_save_IFS
10186   test -z "$as_dir" && as_dir=.
10187   for ac_exec_ext in '' $ac_executable_extensions; do
10188   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10189     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10190     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10191     break 2
10192   fi
10193 done
10194 done
10195
10196 fi
10197 fi
10198 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10199 if test -n "$DLLTOOL_FOR_TARGET"; then
10200   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10201 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10202 else
10203   echo "$as_me:$LINENO: result: no" >&5
10204 echo "${ECHO_T}no" >&6
10205 fi
10206
10207     fi
10208     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10209   done
10210 fi
10211
10212 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10213   set dummy dlltool
10214   if test $build = $target ; then
10215     DLLTOOL_FOR_TARGET="$2"
10216   else
10217     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10218   fi
10219 else
10220   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10221 fi
10222
10223 else
10224   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10225 fi
10226
10227
10228
10229
10230 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10231   if test -n "$with_build_time_tools"; then
10232     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10233 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10234     if test -x $with_build_time_tools/ld; then
10235       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10236       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10237       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10238 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10239     else
10240       echo "$as_me:$LINENO: result: no" >&5
10241 echo "${ECHO_T}no" >&6
10242     fi
10243   elif test $build != $host && test $have_gcc_for_target = yes; then
10244     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10245     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10246     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10247   fi
10248 fi
10249 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10250   # Extract the first word of "ld", so it can be a program name with args.
10251 set dummy ld; ac_word=$2
10252 echo "$as_me:$LINENO: checking for $ac_word" >&5
10253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10254 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10255   echo $ECHO_N "(cached) $ECHO_C" >&6
10256 else
10257   case $LD_FOR_TARGET in
10258   [\\/]* | ?:[\\/]*)
10259   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10260   ;;
10261   *)
10262   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10263 for as_dir in $gcc_cv_tool_dirs
10264 do
10265   IFS=$as_save_IFS
10266   test -z "$as_dir" && as_dir=.
10267   for ac_exec_ext in '' $ac_executable_extensions; do
10268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10269     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10271     break 2
10272   fi
10273 done
10274 done
10275
10276   ;;
10277 esac
10278 fi
10279 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10280
10281 if test -n "$LD_FOR_TARGET"; then
10282   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10283 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10284 else
10285   echo "$as_me:$LINENO: result: no" >&5
10286 echo "${ECHO_T}no" >&6
10287 fi
10288
10289 fi
10290 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10291
10292
10293 if test -n "$LD_FOR_TARGET"; then
10294   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10295 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10296   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10297 fi
10298
10299 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10300   for ncn_progname in ld; do
10301     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10302 set dummy ${ncn_progname}; ac_word=$2
10303 echo "$as_me:$LINENO: checking for $ac_word" >&5
10304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10305 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10306   echo $ECHO_N "(cached) $ECHO_C" >&6
10307 else
10308   if test -n "$LD_FOR_TARGET"; then
10309   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10310 else
10311 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10312 for as_dir in $PATH
10313 do
10314   IFS=$as_save_IFS
10315   test -z "$as_dir" && as_dir=.
10316   for ac_exec_ext in '' $ac_executable_extensions; do
10317   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10318     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10319     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10320     break 2
10321   fi
10322 done
10323 done
10324
10325 fi
10326 fi
10327 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10328 if test -n "$LD_FOR_TARGET"; then
10329   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10330 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10331 else
10332   echo "$as_me:$LINENO: result: no" >&5
10333 echo "${ECHO_T}no" >&6
10334 fi
10335
10336   done
10337 fi
10338
10339 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10340   for ncn_progname in ld; do
10341     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10342 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10343     if test -x $with_build_time_tools/${ncn_progname}; then
10344       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10345       echo "$as_me:$LINENO: result: yes" >&5
10346 echo "${ECHO_T}yes" >&6
10347       break
10348     else
10349       echo "$as_me:$LINENO: result: no" >&5
10350 echo "${ECHO_T}no" >&6
10351     fi
10352   done
10353 fi
10354
10355 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10356   for ncn_progname in ld; do
10357     if test -n "$ncn_target_tool_prefix"; then
10358       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10359 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10360 echo "$as_me:$LINENO: checking for $ac_word" >&5
10361 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10362 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10363   echo $ECHO_N "(cached) $ECHO_C" >&6
10364 else
10365   if test -n "$LD_FOR_TARGET"; then
10366   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10367 else
10368 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10369 for as_dir in $PATH
10370 do
10371   IFS=$as_save_IFS
10372   test -z "$as_dir" && as_dir=.
10373   for ac_exec_ext in '' $ac_executable_extensions; do
10374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10375     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10377     break 2
10378   fi
10379 done
10380 done
10381
10382 fi
10383 fi
10384 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10385 if test -n "$LD_FOR_TARGET"; then
10386   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10387 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10388 else
10389   echo "$as_me:$LINENO: result: no" >&5
10390 echo "${ECHO_T}no" >&6
10391 fi
10392
10393     fi
10394     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10395       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10396 set dummy ${ncn_progname}; ac_word=$2
10397 echo "$as_me:$LINENO: checking for $ac_word" >&5
10398 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10399 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10400   echo $ECHO_N "(cached) $ECHO_C" >&6
10401 else
10402   if test -n "$LD_FOR_TARGET"; then
10403   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10404 else
10405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10406 for as_dir in $PATH
10407 do
10408   IFS=$as_save_IFS
10409   test -z "$as_dir" && as_dir=.
10410   for ac_exec_ext in '' $ac_executable_extensions; do
10411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10412     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10414     break 2
10415   fi
10416 done
10417 done
10418
10419 fi
10420 fi
10421 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10422 if test -n "$LD_FOR_TARGET"; then
10423   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10424 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10425 else
10426   echo "$as_me:$LINENO: result: no" >&5
10427 echo "${ECHO_T}no" >&6
10428 fi
10429
10430     fi
10431     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10432   done
10433 fi
10434
10435 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10436   set dummy ld
10437   if test $build = $target ; then
10438     LD_FOR_TARGET="$2"
10439   else
10440     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10441   fi
10442 else
10443   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10444 fi
10445
10446 else
10447   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10448 fi
10449
10450
10451
10452
10453 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10454   if test -n "$with_build_time_tools"; then
10455     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10456 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10457     if test -x $with_build_time_tools/lipo; then
10458       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10459       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10460       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10461 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10462     else
10463       echo "$as_me:$LINENO: result: no" >&5
10464 echo "${ECHO_T}no" >&6
10465     fi
10466   elif test $build != $host && test $have_gcc_for_target = yes; then
10467     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10468     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10469     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10470   fi
10471 fi
10472 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10473   # Extract the first word of "lipo", so it can be a program name with args.
10474 set dummy lipo; ac_word=$2
10475 echo "$as_me:$LINENO: checking for $ac_word" >&5
10476 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10477 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10478   echo $ECHO_N "(cached) $ECHO_C" >&6
10479 else
10480   case $LIPO_FOR_TARGET in
10481   [\\/]* | ?:[\\/]*)
10482   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10483   ;;
10484   *)
10485   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10486 for as_dir in $gcc_cv_tool_dirs
10487 do
10488   IFS=$as_save_IFS
10489   test -z "$as_dir" && as_dir=.
10490   for ac_exec_ext in '' $ac_executable_extensions; do
10491   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10492     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10493     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10494     break 2
10495   fi
10496 done
10497 done
10498
10499   ;;
10500 esac
10501 fi
10502 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10503
10504 if test -n "$LIPO_FOR_TARGET"; then
10505   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10506 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10507 else
10508   echo "$as_me:$LINENO: result: no" >&5
10509 echo "${ECHO_T}no" >&6
10510 fi
10511
10512 fi
10513 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10514
10515
10516 if test -n "$LIPO_FOR_TARGET"; then
10517   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10518 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10519   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10520 fi
10521
10522 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10523   for ncn_progname in lipo; do
10524     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10525 set dummy ${ncn_progname}; ac_word=$2
10526 echo "$as_me:$LINENO: checking for $ac_word" >&5
10527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10528 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10529   echo $ECHO_N "(cached) $ECHO_C" >&6
10530 else
10531   if test -n "$LIPO_FOR_TARGET"; then
10532   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10533 else
10534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10535 for as_dir in $PATH
10536 do
10537   IFS=$as_save_IFS
10538   test -z "$as_dir" && as_dir=.
10539   for ac_exec_ext in '' $ac_executable_extensions; do
10540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10541     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10543     break 2
10544   fi
10545 done
10546 done
10547
10548 fi
10549 fi
10550 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10551 if test -n "$LIPO_FOR_TARGET"; then
10552   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10553 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10554 else
10555   echo "$as_me:$LINENO: result: no" >&5
10556 echo "${ECHO_T}no" >&6
10557 fi
10558
10559   done
10560 fi
10561
10562 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10563   for ncn_progname in lipo; do
10564     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10565 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10566     if test -x $with_build_time_tools/${ncn_progname}; then
10567       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10568       echo "$as_me:$LINENO: result: yes" >&5
10569 echo "${ECHO_T}yes" >&6
10570       break
10571     else
10572       echo "$as_me:$LINENO: result: no" >&5
10573 echo "${ECHO_T}no" >&6
10574     fi
10575   done
10576 fi
10577
10578 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10579   for ncn_progname in lipo; do
10580     if test -n "$ncn_target_tool_prefix"; then
10581       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10582 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10583 echo "$as_me:$LINENO: checking for $ac_word" >&5
10584 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10585 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10586   echo $ECHO_N "(cached) $ECHO_C" >&6
10587 else
10588   if test -n "$LIPO_FOR_TARGET"; then
10589   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10590 else
10591 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10592 for as_dir in $PATH
10593 do
10594   IFS=$as_save_IFS
10595   test -z "$as_dir" && as_dir=.
10596   for ac_exec_ext in '' $ac_executable_extensions; do
10597   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10598     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10599     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10600     break 2
10601   fi
10602 done
10603 done
10604
10605 fi
10606 fi
10607 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10608 if test -n "$LIPO_FOR_TARGET"; then
10609   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10610 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10611 else
10612   echo "$as_me:$LINENO: result: no" >&5
10613 echo "${ECHO_T}no" >&6
10614 fi
10615
10616     fi
10617     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10618       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10619 set dummy ${ncn_progname}; ac_word=$2
10620 echo "$as_me:$LINENO: checking for $ac_word" >&5
10621 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10622 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10623   echo $ECHO_N "(cached) $ECHO_C" >&6
10624 else
10625   if test -n "$LIPO_FOR_TARGET"; then
10626   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10627 else
10628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10629 for as_dir in $PATH
10630 do
10631   IFS=$as_save_IFS
10632   test -z "$as_dir" && as_dir=.
10633   for ac_exec_ext in '' $ac_executable_extensions; do
10634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10635     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10637     break 2
10638   fi
10639 done
10640 done
10641
10642 fi
10643 fi
10644 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10645 if test -n "$LIPO_FOR_TARGET"; then
10646   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10647 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10648 else
10649   echo "$as_me:$LINENO: result: no" >&5
10650 echo "${ECHO_T}no" >&6
10651 fi
10652
10653     fi
10654     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10655   done
10656 fi
10657
10658 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10659   set dummy lipo
10660   if test $build = $target ; then
10661     LIPO_FOR_TARGET="$2"
10662   else
10663     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10664   fi
10665 else
10666   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10667 fi
10668
10669 else
10670   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10671 fi
10672
10673
10674
10675
10676 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10677   if test -n "$with_build_time_tools"; then
10678     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10679 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10680     if test -x $with_build_time_tools/nm; then
10681       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10682       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10683       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10684 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10685     else
10686       echo "$as_me:$LINENO: result: no" >&5
10687 echo "${ECHO_T}no" >&6
10688     fi
10689   elif test $build != $host && test $have_gcc_for_target = yes; then
10690     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10691     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10692     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10693   fi
10694 fi
10695 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10696   # Extract the first word of "nm", so it can be a program name with args.
10697 set dummy nm; ac_word=$2
10698 echo "$as_me:$LINENO: checking for $ac_word" >&5
10699 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10700 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10701   echo $ECHO_N "(cached) $ECHO_C" >&6
10702 else
10703   case $NM_FOR_TARGET in
10704   [\\/]* | ?:[\\/]*)
10705   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10706   ;;
10707   *)
10708   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10709 for as_dir in $gcc_cv_tool_dirs
10710 do
10711   IFS=$as_save_IFS
10712   test -z "$as_dir" && as_dir=.
10713   for ac_exec_ext in '' $ac_executable_extensions; do
10714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10715     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10717     break 2
10718   fi
10719 done
10720 done
10721
10722   ;;
10723 esac
10724 fi
10725 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10726
10727 if test -n "$NM_FOR_TARGET"; then
10728   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10729 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10730 else
10731   echo "$as_me:$LINENO: result: no" >&5
10732 echo "${ECHO_T}no" >&6
10733 fi
10734
10735 fi
10736 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10737
10738
10739 if test -n "$NM_FOR_TARGET"; then
10740   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10741 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10742   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10743 fi
10744
10745 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10746   for ncn_progname in nm; do
10747     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10748 set dummy ${ncn_progname}; ac_word=$2
10749 echo "$as_me:$LINENO: checking for $ac_word" >&5
10750 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10751 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10752   echo $ECHO_N "(cached) $ECHO_C" >&6
10753 else
10754   if test -n "$NM_FOR_TARGET"; then
10755   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10756 else
10757 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10758 for as_dir in $PATH
10759 do
10760   IFS=$as_save_IFS
10761   test -z "$as_dir" && as_dir=.
10762   for ac_exec_ext in '' $ac_executable_extensions; do
10763   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10764     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10765     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10766     break 2
10767   fi
10768 done
10769 done
10770
10771 fi
10772 fi
10773 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10774 if test -n "$NM_FOR_TARGET"; then
10775   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10776 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10777 else
10778   echo "$as_me:$LINENO: result: no" >&5
10779 echo "${ECHO_T}no" >&6
10780 fi
10781
10782   done
10783 fi
10784
10785 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10786   for ncn_progname in nm; do
10787     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10788 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10789     if test -x $with_build_time_tools/${ncn_progname}; then
10790       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10791       echo "$as_me:$LINENO: result: yes" >&5
10792 echo "${ECHO_T}yes" >&6
10793       break
10794     else
10795       echo "$as_me:$LINENO: result: no" >&5
10796 echo "${ECHO_T}no" >&6
10797     fi
10798   done
10799 fi
10800
10801 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10802   for ncn_progname in nm; do
10803     if test -n "$ncn_target_tool_prefix"; then
10804       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10805 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10806 echo "$as_me:$LINENO: checking for $ac_word" >&5
10807 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10808 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10809   echo $ECHO_N "(cached) $ECHO_C" >&6
10810 else
10811   if test -n "$NM_FOR_TARGET"; then
10812   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10813 else
10814 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10815 for as_dir in $PATH
10816 do
10817   IFS=$as_save_IFS
10818   test -z "$as_dir" && as_dir=.
10819   for ac_exec_ext in '' $ac_executable_extensions; do
10820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10821     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10823     break 2
10824   fi
10825 done
10826 done
10827
10828 fi
10829 fi
10830 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10831 if test -n "$NM_FOR_TARGET"; then
10832   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10833 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10834 else
10835   echo "$as_me:$LINENO: result: no" >&5
10836 echo "${ECHO_T}no" >&6
10837 fi
10838
10839     fi
10840     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10841       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10842 set dummy ${ncn_progname}; ac_word=$2
10843 echo "$as_me:$LINENO: checking for $ac_word" >&5
10844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10845 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10846   echo $ECHO_N "(cached) $ECHO_C" >&6
10847 else
10848   if test -n "$NM_FOR_TARGET"; then
10849   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10850 else
10851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10852 for as_dir in $PATH
10853 do
10854   IFS=$as_save_IFS
10855   test -z "$as_dir" && as_dir=.
10856   for ac_exec_ext in '' $ac_executable_extensions; do
10857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10858     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10860     break 2
10861   fi
10862 done
10863 done
10864
10865 fi
10866 fi
10867 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10868 if test -n "$NM_FOR_TARGET"; then
10869   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10870 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10871 else
10872   echo "$as_me:$LINENO: result: no" >&5
10873 echo "${ECHO_T}no" >&6
10874 fi
10875
10876     fi
10877     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10878   done
10879 fi
10880
10881 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10882   set dummy nm
10883   if test $build = $target ; then
10884     NM_FOR_TARGET="$2"
10885   else
10886     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10887   fi
10888 else
10889   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10890 fi
10891
10892 else
10893   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10894 fi
10895
10896
10897
10898
10899 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10900   if test -n "$with_build_time_tools"; then
10901     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10902 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10903     if test -x $with_build_time_tools/objdump; then
10904       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10905       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10906       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10907 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10908     else
10909       echo "$as_me:$LINENO: result: no" >&5
10910 echo "${ECHO_T}no" >&6
10911     fi
10912   elif test $build != $host && test $have_gcc_for_target = yes; then
10913     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10914     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10915     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10916   fi
10917 fi
10918 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10919   # Extract the first word of "objdump", so it can be a program name with args.
10920 set dummy objdump; ac_word=$2
10921 echo "$as_me:$LINENO: checking for $ac_word" >&5
10922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10923 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10924   echo $ECHO_N "(cached) $ECHO_C" >&6
10925 else
10926   case $OBJDUMP_FOR_TARGET in
10927   [\\/]* | ?:[\\/]*)
10928   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10929   ;;
10930   *)
10931   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10932 for as_dir in $gcc_cv_tool_dirs
10933 do
10934   IFS=$as_save_IFS
10935   test -z "$as_dir" && as_dir=.
10936   for ac_exec_ext in '' $ac_executable_extensions; do
10937   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10938     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10939     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10940     break 2
10941   fi
10942 done
10943 done
10944
10945   ;;
10946 esac
10947 fi
10948 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10949
10950 if test -n "$OBJDUMP_FOR_TARGET"; then
10951   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10952 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10953 else
10954   echo "$as_me:$LINENO: result: no" >&5
10955 echo "${ECHO_T}no" >&6
10956 fi
10957
10958 fi
10959 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10960
10961
10962 if test -n "$OBJDUMP_FOR_TARGET"; then
10963   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10964 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10965   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10966 fi
10967
10968 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10969   for ncn_progname in objdump; do
10970     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10971 set dummy ${ncn_progname}; ac_word=$2
10972 echo "$as_me:$LINENO: checking for $ac_word" >&5
10973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10974 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10975   echo $ECHO_N "(cached) $ECHO_C" >&6
10976 else
10977   if test -n "$OBJDUMP_FOR_TARGET"; then
10978   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10979 else
10980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10981 for as_dir in $PATH
10982 do
10983   IFS=$as_save_IFS
10984   test -z "$as_dir" && as_dir=.
10985   for ac_exec_ext in '' $ac_executable_extensions; do
10986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10987     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10989     break 2
10990   fi
10991 done
10992 done
10993
10994 fi
10995 fi
10996 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10997 if test -n "$OBJDUMP_FOR_TARGET"; then
10998   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10999 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11000 else
11001   echo "$as_me:$LINENO: result: no" >&5
11002 echo "${ECHO_T}no" >&6
11003 fi
11004
11005   done
11006 fi
11007
11008 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11009   for ncn_progname in objdump; do
11010     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11011 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11012     if test -x $with_build_time_tools/${ncn_progname}; then
11013       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11014       echo "$as_me:$LINENO: result: yes" >&5
11015 echo "${ECHO_T}yes" >&6
11016       break
11017     else
11018       echo "$as_me:$LINENO: result: no" >&5
11019 echo "${ECHO_T}no" >&6
11020     fi
11021   done
11022 fi
11023
11024 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
11025   for ncn_progname in objdump; do
11026     if test -n "$ncn_target_tool_prefix"; then
11027       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11028 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11029 echo "$as_me:$LINENO: checking for $ac_word" >&5
11030 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11031 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11032   echo $ECHO_N "(cached) $ECHO_C" >&6
11033 else
11034   if test -n "$OBJDUMP_FOR_TARGET"; then
11035   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11036 else
11037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11038 for as_dir in $PATH
11039 do
11040   IFS=$as_save_IFS
11041   test -z "$as_dir" && as_dir=.
11042   for ac_exec_ext in '' $ac_executable_extensions; do
11043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11044     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11046     break 2
11047   fi
11048 done
11049 done
11050
11051 fi
11052 fi
11053 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11054 if test -n "$OBJDUMP_FOR_TARGET"; then
11055   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11056 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11057 else
11058   echo "$as_me:$LINENO: result: no" >&5
11059 echo "${ECHO_T}no" >&6
11060 fi
11061
11062     fi
11063     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
11064       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11065 set dummy ${ncn_progname}; ac_word=$2
11066 echo "$as_me:$LINENO: checking for $ac_word" >&5
11067 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11068 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11069   echo $ECHO_N "(cached) $ECHO_C" >&6
11070 else
11071   if test -n "$OBJDUMP_FOR_TARGET"; then
11072   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11073 else
11074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11075 for as_dir in $PATH
11076 do
11077   IFS=$as_save_IFS
11078   test -z "$as_dir" && as_dir=.
11079   for ac_exec_ext in '' $ac_executable_extensions; do
11080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11081     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
11082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11083     break 2
11084   fi
11085 done
11086 done
11087
11088 fi
11089 fi
11090 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11091 if test -n "$OBJDUMP_FOR_TARGET"; then
11092   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11093 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11094 else
11095   echo "$as_me:$LINENO: result: no" >&5
11096 echo "${ECHO_T}no" >&6
11097 fi
11098
11099     fi
11100     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11101   done
11102 fi
11103
11104 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11105   set dummy objdump
11106   if test $build = $target ; then
11107     OBJDUMP_FOR_TARGET="$2"
11108   else
11109     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11110   fi
11111 else
11112   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11113 fi
11114
11115 else
11116   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11117 fi
11118
11119
11120
11121
11122 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11123   if test -n "$with_build_time_tools"; then
11124     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11125 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11126     if test -x $with_build_time_tools/ranlib; then
11127       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11128       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11129       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11130 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11131     else
11132       echo "$as_me:$LINENO: result: no" >&5
11133 echo "${ECHO_T}no" >&6
11134     fi
11135   elif test $build != $host && test $have_gcc_for_target = yes; then
11136     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11137     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11138     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11139   fi
11140 fi
11141 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11142   # Extract the first word of "ranlib", so it can be a program name with args.
11143 set dummy ranlib; ac_word=$2
11144 echo "$as_me:$LINENO: checking for $ac_word" >&5
11145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11146 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11147   echo $ECHO_N "(cached) $ECHO_C" >&6
11148 else
11149   case $RANLIB_FOR_TARGET in
11150   [\\/]* | ?:[\\/]*)
11151   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11152   ;;
11153   *)
11154   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11155 for as_dir in $gcc_cv_tool_dirs
11156 do
11157   IFS=$as_save_IFS
11158   test -z "$as_dir" && as_dir=.
11159   for ac_exec_ext in '' $ac_executable_extensions; do
11160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11161     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11163     break 2
11164   fi
11165 done
11166 done
11167
11168   ;;
11169 esac
11170 fi
11171 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11172
11173 if test -n "$RANLIB_FOR_TARGET"; then
11174   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11175 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11176 else
11177   echo "$as_me:$LINENO: result: no" >&5
11178 echo "${ECHO_T}no" >&6
11179 fi
11180
11181 fi
11182 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11183
11184
11185 if test -n "$RANLIB_FOR_TARGET"; then
11186   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11187 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11188   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11189 fi
11190
11191 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11192   for ncn_progname in ranlib; do
11193     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11194 set dummy ${ncn_progname}; ac_word=$2
11195 echo "$as_me:$LINENO: checking for $ac_word" >&5
11196 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11197 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11198   echo $ECHO_N "(cached) $ECHO_C" >&6
11199 else
11200   if test -n "$RANLIB_FOR_TARGET"; then
11201   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11202 else
11203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11204 for as_dir in $PATH
11205 do
11206   IFS=$as_save_IFS
11207   test -z "$as_dir" && as_dir=.
11208   for ac_exec_ext in '' $ac_executable_extensions; do
11209   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11210     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11211     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11212     break 2
11213   fi
11214 done
11215 done
11216
11217 fi
11218 fi
11219 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11220 if test -n "$RANLIB_FOR_TARGET"; then
11221   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11222 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11223 else
11224   echo "$as_me:$LINENO: result: no" >&5
11225 echo "${ECHO_T}no" >&6
11226 fi
11227
11228   done
11229 fi
11230
11231 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11232   for ncn_progname in ranlib; do
11233     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11234 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11235     if test -x $with_build_time_tools/${ncn_progname}; then
11236       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11237       echo "$as_me:$LINENO: result: yes" >&5
11238 echo "${ECHO_T}yes" >&6
11239       break
11240     else
11241       echo "$as_me:$LINENO: result: no" >&5
11242 echo "${ECHO_T}no" >&6
11243     fi
11244   done
11245 fi
11246
11247 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11248   for ncn_progname in ranlib; do
11249     if test -n "$ncn_target_tool_prefix"; then
11250       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11251 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11252 echo "$as_me:$LINENO: checking for $ac_word" >&5
11253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11254 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11255   echo $ECHO_N "(cached) $ECHO_C" >&6
11256 else
11257   if test -n "$RANLIB_FOR_TARGET"; then
11258   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11259 else
11260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11261 for as_dir in $PATH
11262 do
11263   IFS=$as_save_IFS
11264   test -z "$as_dir" && as_dir=.
11265   for ac_exec_ext in '' $ac_executable_extensions; do
11266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11267     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11269     break 2
11270   fi
11271 done
11272 done
11273
11274 fi
11275 fi
11276 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11277 if test -n "$RANLIB_FOR_TARGET"; then
11278   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11279 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11280 else
11281   echo "$as_me:$LINENO: result: no" >&5
11282 echo "${ECHO_T}no" >&6
11283 fi
11284
11285     fi
11286     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11287       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11288 set dummy ${ncn_progname}; ac_word=$2
11289 echo "$as_me:$LINENO: checking for $ac_word" >&5
11290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11291 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11292   echo $ECHO_N "(cached) $ECHO_C" >&6
11293 else
11294   if test -n "$RANLIB_FOR_TARGET"; then
11295   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11296 else
11297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11298 for as_dir in $PATH
11299 do
11300   IFS=$as_save_IFS
11301   test -z "$as_dir" && as_dir=.
11302   for ac_exec_ext in '' $ac_executable_extensions; do
11303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11304     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11306     break 2
11307   fi
11308 done
11309 done
11310
11311 fi
11312 fi
11313 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11314 if test -n "$RANLIB_FOR_TARGET"; then
11315   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11316 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11317 else
11318   echo "$as_me:$LINENO: result: no" >&5
11319 echo "${ECHO_T}no" >&6
11320 fi
11321
11322     fi
11323     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11324   done
11325 fi
11326
11327 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11328   set dummy ranlib
11329   if test $build = $target ; then
11330     RANLIB_FOR_TARGET="$2"
11331   else
11332     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11333   fi
11334 else
11335   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11336 fi
11337
11338 else
11339   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11340 fi
11341
11342
11343
11344
11345 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11346   if test -n "$with_build_time_tools"; then
11347     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11348 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11349     if test -x $with_build_time_tools/strip; then
11350       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11351       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11352       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11353 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11354     else
11355       echo "$as_me:$LINENO: result: no" >&5
11356 echo "${ECHO_T}no" >&6
11357     fi
11358   elif test $build != $host && test $have_gcc_for_target = yes; then
11359     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11360     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11361     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11362   fi
11363 fi
11364 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11365   # Extract the first word of "strip", so it can be a program name with args.
11366 set dummy strip; ac_word=$2
11367 echo "$as_me:$LINENO: checking for $ac_word" >&5
11368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11369 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11370   echo $ECHO_N "(cached) $ECHO_C" >&6
11371 else
11372   case $STRIP_FOR_TARGET in
11373   [\\/]* | ?:[\\/]*)
11374   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11375   ;;
11376   *)
11377   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11378 for as_dir in $gcc_cv_tool_dirs
11379 do
11380   IFS=$as_save_IFS
11381   test -z "$as_dir" && as_dir=.
11382   for ac_exec_ext in '' $ac_executable_extensions; do
11383   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11384     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11385     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11386     break 2
11387   fi
11388 done
11389 done
11390
11391   ;;
11392 esac
11393 fi
11394 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11395
11396 if test -n "$STRIP_FOR_TARGET"; then
11397   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11398 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11399 else
11400   echo "$as_me:$LINENO: result: no" >&5
11401 echo "${ECHO_T}no" >&6
11402 fi
11403
11404 fi
11405 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11406
11407
11408 if test -n "$STRIP_FOR_TARGET"; then
11409   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11410 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11411   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11412 fi
11413
11414 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11415   for ncn_progname in strip; do
11416     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11417 set dummy ${ncn_progname}; ac_word=$2
11418 echo "$as_me:$LINENO: checking for $ac_word" >&5
11419 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11420 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11421   echo $ECHO_N "(cached) $ECHO_C" >&6
11422 else
11423   if test -n "$STRIP_FOR_TARGET"; then
11424   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11425 else
11426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11427 for as_dir in $PATH
11428 do
11429   IFS=$as_save_IFS
11430   test -z "$as_dir" && as_dir=.
11431   for ac_exec_ext in '' $ac_executable_extensions; do
11432   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11433     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11434     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11435     break 2
11436   fi
11437 done
11438 done
11439
11440 fi
11441 fi
11442 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11443 if test -n "$STRIP_FOR_TARGET"; then
11444   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11445 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11446 else
11447   echo "$as_me:$LINENO: result: no" >&5
11448 echo "${ECHO_T}no" >&6
11449 fi
11450
11451   done
11452 fi
11453
11454 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11455   for ncn_progname in strip; do
11456     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11457 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11458     if test -x $with_build_time_tools/${ncn_progname}; then
11459       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11460       echo "$as_me:$LINENO: result: yes" >&5
11461 echo "${ECHO_T}yes" >&6
11462       break
11463     else
11464       echo "$as_me:$LINENO: result: no" >&5
11465 echo "${ECHO_T}no" >&6
11466     fi
11467   done
11468 fi
11469
11470 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11471   for ncn_progname in strip; do
11472     if test -n "$ncn_target_tool_prefix"; then
11473       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11474 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11475 echo "$as_me:$LINENO: checking for $ac_word" >&5
11476 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11477 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11478   echo $ECHO_N "(cached) $ECHO_C" >&6
11479 else
11480   if test -n "$STRIP_FOR_TARGET"; then
11481   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11482 else
11483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11484 for as_dir in $PATH
11485 do
11486   IFS=$as_save_IFS
11487   test -z "$as_dir" && as_dir=.
11488   for ac_exec_ext in '' $ac_executable_extensions; do
11489   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11490     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11491     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11492     break 2
11493   fi
11494 done
11495 done
11496
11497 fi
11498 fi
11499 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11500 if test -n "$STRIP_FOR_TARGET"; then
11501   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11502 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11503 else
11504   echo "$as_me:$LINENO: result: no" >&5
11505 echo "${ECHO_T}no" >&6
11506 fi
11507
11508     fi
11509     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11510       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11511 set dummy ${ncn_progname}; ac_word=$2
11512 echo "$as_me:$LINENO: checking for $ac_word" >&5
11513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11514 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11515   echo $ECHO_N "(cached) $ECHO_C" >&6
11516 else
11517   if test -n "$STRIP_FOR_TARGET"; then
11518   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11519 else
11520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11521 for as_dir in $PATH
11522 do
11523   IFS=$as_save_IFS
11524   test -z "$as_dir" && as_dir=.
11525   for ac_exec_ext in '' $ac_executable_extensions; do
11526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11527     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11529     break 2
11530   fi
11531 done
11532 done
11533
11534 fi
11535 fi
11536 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11537 if test -n "$STRIP_FOR_TARGET"; then
11538   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11539 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11540 else
11541   echo "$as_me:$LINENO: result: no" >&5
11542 echo "${ECHO_T}no" >&6
11543 fi
11544
11545     fi
11546     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11547   done
11548 fi
11549
11550 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11551   set dummy strip
11552   if test $build = $target ; then
11553     STRIP_FOR_TARGET="$2"
11554   else
11555     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11556   fi
11557 else
11558   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11559 fi
11560
11561 else
11562   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11563 fi
11564
11565
11566
11567
11568 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11569   if test -n "$with_build_time_tools"; then
11570     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11571 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11572     if test -x $with_build_time_tools/windres; then
11573       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11574       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11575       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11576 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11577     else
11578       echo "$as_me:$LINENO: result: no" >&5
11579 echo "${ECHO_T}no" >&6
11580     fi
11581   elif test $build != $host && test $have_gcc_for_target = yes; then
11582     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11583     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11584     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11585   fi
11586 fi
11587 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11588   # Extract the first word of "windres", so it can be a program name with args.
11589 set dummy windres; ac_word=$2
11590 echo "$as_me:$LINENO: checking for $ac_word" >&5
11591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11592 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11593   echo $ECHO_N "(cached) $ECHO_C" >&6
11594 else
11595   case $WINDRES_FOR_TARGET in
11596   [\\/]* | ?:[\\/]*)
11597   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11598   ;;
11599   *)
11600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11601 for as_dir in $gcc_cv_tool_dirs
11602 do
11603   IFS=$as_save_IFS
11604   test -z "$as_dir" && as_dir=.
11605   for ac_exec_ext in '' $ac_executable_extensions; do
11606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11607     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11609     break 2
11610   fi
11611 done
11612 done
11613
11614   ;;
11615 esac
11616 fi
11617 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11618
11619 if test -n "$WINDRES_FOR_TARGET"; then
11620   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11621 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11622 else
11623   echo "$as_me:$LINENO: result: no" >&5
11624 echo "${ECHO_T}no" >&6
11625 fi
11626
11627 fi
11628 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11629
11630
11631 if test -n "$WINDRES_FOR_TARGET"; then
11632   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11633 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11634   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11635 fi
11636
11637 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11638   for ncn_progname in windres; do
11639     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11640 set dummy ${ncn_progname}; ac_word=$2
11641 echo "$as_me:$LINENO: checking for $ac_word" >&5
11642 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11643 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11644   echo $ECHO_N "(cached) $ECHO_C" >&6
11645 else
11646   if test -n "$WINDRES_FOR_TARGET"; then
11647   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11648 else
11649 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11650 for as_dir in $PATH
11651 do
11652   IFS=$as_save_IFS
11653   test -z "$as_dir" && as_dir=.
11654   for ac_exec_ext in '' $ac_executable_extensions; do
11655   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11656     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11657     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11658     break 2
11659   fi
11660 done
11661 done
11662
11663 fi
11664 fi
11665 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11666 if test -n "$WINDRES_FOR_TARGET"; then
11667   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11668 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11669 else
11670   echo "$as_me:$LINENO: result: no" >&5
11671 echo "${ECHO_T}no" >&6
11672 fi
11673
11674   done
11675 fi
11676
11677 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11678   for ncn_progname in windres; do
11679     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11680 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11681     if test -x $with_build_time_tools/${ncn_progname}; then
11682       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11683       echo "$as_me:$LINENO: result: yes" >&5
11684 echo "${ECHO_T}yes" >&6
11685       break
11686     else
11687       echo "$as_me:$LINENO: result: no" >&5
11688 echo "${ECHO_T}no" >&6
11689     fi
11690   done
11691 fi
11692
11693 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11694   for ncn_progname in windres; do
11695     if test -n "$ncn_target_tool_prefix"; then
11696       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11697 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11698 echo "$as_me:$LINENO: checking for $ac_word" >&5
11699 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11700 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11701   echo $ECHO_N "(cached) $ECHO_C" >&6
11702 else
11703   if test -n "$WINDRES_FOR_TARGET"; then
11704   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11705 else
11706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11707 for as_dir in $PATH
11708 do
11709   IFS=$as_save_IFS
11710   test -z "$as_dir" && as_dir=.
11711   for ac_exec_ext in '' $ac_executable_extensions; do
11712   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11713     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11714     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11715     break 2
11716   fi
11717 done
11718 done
11719
11720 fi
11721 fi
11722 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11723 if test -n "$WINDRES_FOR_TARGET"; then
11724   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11725 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11726 else
11727   echo "$as_me:$LINENO: result: no" >&5
11728 echo "${ECHO_T}no" >&6
11729 fi
11730
11731     fi
11732     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11733       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11734 set dummy ${ncn_progname}; ac_word=$2
11735 echo "$as_me:$LINENO: checking for $ac_word" >&5
11736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11737 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11738   echo $ECHO_N "(cached) $ECHO_C" >&6
11739 else
11740   if test -n "$WINDRES_FOR_TARGET"; then
11741   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11742 else
11743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11744 for as_dir in $PATH
11745 do
11746   IFS=$as_save_IFS
11747   test -z "$as_dir" && as_dir=.
11748   for ac_exec_ext in '' $ac_executable_extensions; do
11749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11750     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11752     break 2
11753   fi
11754 done
11755 done
11756
11757 fi
11758 fi
11759 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11760 if test -n "$WINDRES_FOR_TARGET"; then
11761   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11762 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11763 else
11764   echo "$as_me:$LINENO: result: no" >&5
11765 echo "${ECHO_T}no" >&6
11766 fi
11767
11768     fi
11769     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11770   done
11771 fi
11772
11773 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11774   set dummy windres
11775   if test $build = $target ; then
11776     WINDRES_FOR_TARGET="$2"
11777   else
11778     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11779   fi
11780 else
11781   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11782 fi
11783
11784 else
11785   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11786 fi
11787
11788
11789
11790
11791 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11792   if test -n "$with_build_time_tools"; then
11793     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11794 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11795     if test -x $with_build_time_tools/windmc; then
11796       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11797       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11798       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11799 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11800     else
11801       echo "$as_me:$LINENO: result: no" >&5
11802 echo "${ECHO_T}no" >&6
11803     fi
11804   elif test $build != $host && test $have_gcc_for_target = yes; then
11805     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11806     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11807     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11808   fi
11809 fi
11810 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11811   # Extract the first word of "windmc", so it can be a program name with args.
11812 set dummy windmc; ac_word=$2
11813 echo "$as_me:$LINENO: checking for $ac_word" >&5
11814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11815 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11816   echo $ECHO_N "(cached) $ECHO_C" >&6
11817 else
11818   case $WINDMC_FOR_TARGET in
11819   [\\/]* | ?:[\\/]*)
11820   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11821   ;;
11822   *)
11823   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11824 for as_dir in $gcc_cv_tool_dirs
11825 do
11826   IFS=$as_save_IFS
11827   test -z "$as_dir" && as_dir=.
11828   for ac_exec_ext in '' $ac_executable_extensions; do
11829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11830     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11832     break 2
11833   fi
11834 done
11835 done
11836
11837   ;;
11838 esac
11839 fi
11840 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11841
11842 if test -n "$WINDMC_FOR_TARGET"; then
11843   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11844 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11845 else
11846   echo "$as_me:$LINENO: result: no" >&5
11847 echo "${ECHO_T}no" >&6
11848 fi
11849
11850 fi
11851 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11852
11853
11854 if test -n "$WINDMC_FOR_TARGET"; then
11855   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11856 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11857   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11858 fi
11859
11860 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11861   for ncn_progname in windmc; do
11862     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11863 set dummy ${ncn_progname}; ac_word=$2
11864 echo "$as_me:$LINENO: checking for $ac_word" >&5
11865 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11866 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11867   echo $ECHO_N "(cached) $ECHO_C" >&6
11868 else
11869   if test -n "$WINDMC_FOR_TARGET"; then
11870   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11871 else
11872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11873 for as_dir in $PATH
11874 do
11875   IFS=$as_save_IFS
11876   test -z "$as_dir" && as_dir=.
11877   for ac_exec_ext in '' $ac_executable_extensions; do
11878   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11879     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11880     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11881     break 2
11882   fi
11883 done
11884 done
11885
11886 fi
11887 fi
11888 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11889 if test -n "$WINDMC_FOR_TARGET"; then
11890   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11891 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11892 else
11893   echo "$as_me:$LINENO: result: no" >&5
11894 echo "${ECHO_T}no" >&6
11895 fi
11896
11897   done
11898 fi
11899
11900 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11901   for ncn_progname in windmc; do
11902     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11903 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11904     if test -x $with_build_time_tools/${ncn_progname}; then
11905       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11906       echo "$as_me:$LINENO: result: yes" >&5
11907 echo "${ECHO_T}yes" >&6
11908       break
11909     else
11910       echo "$as_me:$LINENO: result: no" >&5
11911 echo "${ECHO_T}no" >&6
11912     fi
11913   done
11914 fi
11915
11916 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11917   for ncn_progname in windmc; do
11918     if test -n "$ncn_target_tool_prefix"; then
11919       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11920 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11921 echo "$as_me:$LINENO: checking for $ac_word" >&5
11922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11923 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11924   echo $ECHO_N "(cached) $ECHO_C" >&6
11925 else
11926   if test -n "$WINDMC_FOR_TARGET"; then
11927   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11928 else
11929 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11930 for as_dir in $PATH
11931 do
11932   IFS=$as_save_IFS
11933   test -z "$as_dir" && as_dir=.
11934   for ac_exec_ext in '' $ac_executable_extensions; do
11935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11936     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11938     break 2
11939   fi
11940 done
11941 done
11942
11943 fi
11944 fi
11945 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11946 if test -n "$WINDMC_FOR_TARGET"; then
11947   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11948 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11949 else
11950   echo "$as_me:$LINENO: result: no" >&5
11951 echo "${ECHO_T}no" >&6
11952 fi
11953
11954     fi
11955     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11956       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11957 set dummy ${ncn_progname}; ac_word=$2
11958 echo "$as_me:$LINENO: checking for $ac_word" >&5
11959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11960 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11961   echo $ECHO_N "(cached) $ECHO_C" >&6
11962 else
11963   if test -n "$WINDMC_FOR_TARGET"; then
11964   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11965 else
11966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11967 for as_dir in $PATH
11968 do
11969   IFS=$as_save_IFS
11970   test -z "$as_dir" && as_dir=.
11971   for ac_exec_ext in '' $ac_executable_extensions; do
11972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11973     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11975     break 2
11976   fi
11977 done
11978 done
11979
11980 fi
11981 fi
11982 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11983 if test -n "$WINDMC_FOR_TARGET"; then
11984   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11985 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11986 else
11987   echo "$as_me:$LINENO: result: no" >&5
11988 echo "${ECHO_T}no" >&6
11989 fi
11990
11991     fi
11992     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11993   done
11994 fi
11995
11996 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11997   set dummy windmc
11998   if test $build = $target ; then
11999     WINDMC_FOR_TARGET="$2"
12000   else
12001     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
12002   fi
12003 else
12004   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
12005 fi
12006
12007 else
12008   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
12009 fi
12010
12011
12012 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
12013
12014 echo "$as_me:$LINENO: checking where to find the target ar" >&5
12015 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
12016 if test "x${build}" != "x${host}" ; then
12017   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12018     # We already found the complete path
12019     ac_dir=`dirname $AR_FOR_TARGET`
12020     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12021 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12022   else
12023     # Canadian cross, just use what we found
12024     echo "$as_me:$LINENO: result: pre-installed" >&5
12025 echo "${ECHO_T}pre-installed" >&6
12026   fi
12027 else
12028   ok=yes
12029   case " ${configdirs} " in
12030     *" binutils "*) ;;
12031     *) ok=no ;;
12032   esac
12033
12034   if test $ok = yes; then
12035     # An in-tree tool is available and we can use it
12036     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
12037     echo "$as_me:$LINENO: result: just compiled" >&5
12038 echo "${ECHO_T}just compiled" >&6
12039   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12040     # We already found the complete path
12041     ac_dir=`dirname $AR_FOR_TARGET`
12042     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12043 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12044   elif test "x$target" = "x$host"; then
12045     # We can use an host tool
12046     AR_FOR_TARGET='$(AR)'
12047     echo "$as_me:$LINENO: result: host tool" >&5
12048 echo "${ECHO_T}host tool" >&6
12049   else
12050     # We need a cross tool
12051     echo "$as_me:$LINENO: result: pre-installed" >&5
12052 echo "${ECHO_T}pre-installed" >&6
12053   fi
12054 fi
12055
12056 echo "$as_me:$LINENO: checking where to find the target as" >&5
12057 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
12058 if test "x${build}" != "x${host}" ; then
12059   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12060     # We already found the complete path
12061     ac_dir=`dirname $AS_FOR_TARGET`
12062     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12063 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12064   else
12065     # Canadian cross, just use what we found
12066     echo "$as_me:$LINENO: result: pre-installed" >&5
12067 echo "${ECHO_T}pre-installed" >&6
12068   fi
12069 else
12070   ok=yes
12071   case " ${configdirs} " in
12072     *" gas "*) ;;
12073     *) ok=no ;;
12074   esac
12075
12076   if test $ok = yes; then
12077     # An in-tree tool is available and we can use it
12078     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
12079     echo "$as_me:$LINENO: result: just compiled" >&5
12080 echo "${ECHO_T}just compiled" >&6
12081   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12082     # We already found the complete path
12083     ac_dir=`dirname $AS_FOR_TARGET`
12084     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12085 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12086   elif test "x$target" = "x$host"; then
12087     # We can use an host tool
12088     AS_FOR_TARGET='$(AS)'
12089     echo "$as_me:$LINENO: result: host tool" >&5
12090 echo "${ECHO_T}host tool" >&6
12091   else
12092     # We need a cross tool
12093     echo "$as_me:$LINENO: result: pre-installed" >&5
12094 echo "${ECHO_T}pre-installed" >&6
12095   fi
12096 fi
12097
12098 echo "$as_me:$LINENO: checking where to find the target cc" >&5
12099 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12100 if test "x${build}" != "x${host}" ; then
12101   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12102     # We already found the complete path
12103     ac_dir=`dirname $CC_FOR_TARGET`
12104     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12105 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12106   else
12107     # Canadian cross, just use what we found
12108     echo "$as_me:$LINENO: result: pre-installed" >&5
12109 echo "${ECHO_T}pre-installed" >&6
12110   fi
12111 else
12112   ok=yes
12113   case " ${configdirs} " in
12114     *" gcc "*) ;;
12115     *) ok=no ;;
12116   esac
12117
12118   if test $ok = yes; then
12119     # An in-tree tool is available and we can use it
12120     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12121     echo "$as_me:$LINENO: result: just compiled" >&5
12122 echo "${ECHO_T}just compiled" >&6
12123   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12124     # We already found the complete path
12125     ac_dir=`dirname $CC_FOR_TARGET`
12126     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12127 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12128   elif test "x$target" = "x$host"; then
12129     # We can use an host tool
12130     CC_FOR_TARGET='$(CC)'
12131     echo "$as_me:$LINENO: result: host tool" >&5
12132 echo "${ECHO_T}host tool" >&6
12133   else
12134     # We need a cross tool
12135     echo "$as_me:$LINENO: result: pre-installed" >&5
12136 echo "${ECHO_T}pre-installed" >&6
12137   fi
12138 fi
12139
12140 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12141 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12142 if test "x${build}" != "x${host}" ; then
12143   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12144     # We already found the complete path
12145     ac_dir=`dirname $CXX_FOR_TARGET`
12146     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12147 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12148   else
12149     # Canadian cross, just use what we found
12150     echo "$as_me:$LINENO: result: pre-installed" >&5
12151 echo "${ECHO_T}pre-installed" >&6
12152   fi
12153 else
12154   ok=yes
12155   case " ${configdirs} " in
12156     *" gcc "*) ;;
12157     *) ok=no ;;
12158   esac
12159   case ,${enable_languages}, in
12160     *,c++,*) ;;
12161     *) ok=no ;;
12162   esac
12163   if test $ok = yes; then
12164     # An in-tree tool is available and we can use it
12165     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'
12166     echo "$as_me:$LINENO: result: just compiled" >&5
12167 echo "${ECHO_T}just compiled" >&6
12168   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12169     # We already found the complete path
12170     ac_dir=`dirname $CXX_FOR_TARGET`
12171     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12172 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12173   elif test "x$target" = "x$host"; then
12174     # We can use an host tool
12175     CXX_FOR_TARGET='$(CXX)'
12176     echo "$as_me:$LINENO: result: host tool" >&5
12177 echo "${ECHO_T}host tool" >&6
12178   else
12179     # We need a cross tool
12180     echo "$as_me:$LINENO: result: pre-installed" >&5
12181 echo "${ECHO_T}pre-installed" >&6
12182   fi
12183 fi
12184
12185 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12186 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12187 if test "x${build}" != "x${host}" ; then
12188   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12189     # We already found the complete path
12190     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12191     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12192 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12193   else
12194     # Canadian cross, just use what we found
12195     echo "$as_me:$LINENO: result: pre-installed" >&5
12196 echo "${ECHO_T}pre-installed" >&6
12197   fi
12198 else
12199   ok=yes
12200   case " ${configdirs} " in
12201     *" gcc "*) ;;
12202     *) ok=no ;;
12203   esac
12204   case ,${enable_languages}, in
12205     *,c++,*) ;;
12206     *) ok=no ;;
12207   esac
12208   if test $ok = yes; then
12209     # An in-tree tool is available and we can use it
12210     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'
12211     echo "$as_me:$LINENO: result: just compiled" >&5
12212 echo "${ECHO_T}just compiled" >&6
12213   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12214     # We already found the complete path
12215     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12216     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12217 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12218   elif test "x$target" = "x$host"; then
12219     # We can use an host tool
12220     RAW_CXX_FOR_TARGET='$(CXX)'
12221     echo "$as_me:$LINENO: result: host tool" >&5
12222 echo "${ECHO_T}host tool" >&6
12223   else
12224     # We need a cross tool
12225     echo "$as_me:$LINENO: result: pre-installed" >&5
12226 echo "${ECHO_T}pre-installed" >&6
12227   fi
12228 fi
12229
12230 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12231 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12232 if test "x${build}" != "x${host}" ; then
12233   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12234     # We already found the complete path
12235     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12236     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12237 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12238   else
12239     # Canadian cross, just use what we found
12240     echo "$as_me:$LINENO: result: pre-installed" >&5
12241 echo "${ECHO_T}pre-installed" >&6
12242   fi
12243 else
12244   ok=yes
12245   case " ${configdirs} " in
12246     *" binutils "*) ;;
12247     *) ok=no ;;
12248   esac
12249
12250   if test $ok = yes; then
12251     # An in-tree tool is available and we can use it
12252     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12253     echo "$as_me:$LINENO: result: just compiled" >&5
12254 echo "${ECHO_T}just compiled" >&6
12255   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12256     # We already found the complete path
12257     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12258     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12259 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12260   elif test "x$target" = "x$host"; then
12261     # We can use an host tool
12262     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12263     echo "$as_me:$LINENO: result: host tool" >&5
12264 echo "${ECHO_T}host tool" >&6
12265   else
12266     # We need a cross tool
12267     echo "$as_me:$LINENO: result: pre-installed" >&5
12268 echo "${ECHO_T}pre-installed" >&6
12269   fi
12270 fi
12271
12272 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12273 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12274 if test "x${build}" != "x${host}" ; then
12275   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12276     # We already found the complete path
12277     ac_dir=`dirname $GCC_FOR_TARGET`
12278     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12279 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12280   else
12281     # Canadian cross, just use what we found
12282     echo "$as_me:$LINENO: result: pre-installed" >&5
12283 echo "${ECHO_T}pre-installed" >&6
12284   fi
12285 else
12286   ok=yes
12287   case " ${configdirs} " in
12288     *" gcc "*) ;;
12289     *) ok=no ;;
12290   esac
12291
12292   if test $ok = yes; then
12293     # An in-tree tool is available and we can use it
12294     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12295     echo "$as_me:$LINENO: result: just compiled" >&5
12296 echo "${ECHO_T}just compiled" >&6
12297   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12298     # We already found the complete path
12299     ac_dir=`dirname $GCC_FOR_TARGET`
12300     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12301 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12302   elif test "x$target" = "x$host"; then
12303     # We can use an host tool
12304     GCC_FOR_TARGET='$()'
12305     echo "$as_me:$LINENO: result: host tool" >&5
12306 echo "${ECHO_T}host tool" >&6
12307   else
12308     # We need a cross tool
12309     echo "$as_me:$LINENO: result: pre-installed" >&5
12310 echo "${ECHO_T}pre-installed" >&6
12311   fi
12312 fi
12313
12314 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12315 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12316 if test "x${build}" != "x${host}" ; then
12317   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12318     # We already found the complete path
12319     ac_dir=`dirname $GCJ_FOR_TARGET`
12320     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12321 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12322   else
12323     # Canadian cross, just use what we found
12324     echo "$as_me:$LINENO: result: pre-installed" >&5
12325 echo "${ECHO_T}pre-installed" >&6
12326   fi
12327 else
12328   ok=yes
12329   case " ${configdirs} " in
12330     *" gcc "*) ;;
12331     *) ok=no ;;
12332   esac
12333   case ,${enable_languages}, in
12334     *,java,*) ;;
12335     *) ok=no ;;
12336   esac
12337   if test $ok = yes; then
12338     # An in-tree tool is available and we can use it
12339     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12340     echo "$as_me:$LINENO: result: just compiled" >&5
12341 echo "${ECHO_T}just compiled" >&6
12342   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12343     # We already found the complete path
12344     ac_dir=`dirname $GCJ_FOR_TARGET`
12345     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12346 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12347   elif test "x$target" = "x$host"; then
12348     # We can use an host tool
12349     GCJ_FOR_TARGET='$(GCJ)'
12350     echo "$as_me:$LINENO: result: host tool" >&5
12351 echo "${ECHO_T}host tool" >&6
12352   else
12353     # We need a cross tool
12354     echo "$as_me:$LINENO: result: pre-installed" >&5
12355 echo "${ECHO_T}pre-installed" >&6
12356   fi
12357 fi
12358
12359 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12360 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12361 if test "x${build}" != "x${host}" ; then
12362   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12363     # We already found the complete path
12364     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12365     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12366 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12367   else
12368     # Canadian cross, just use what we found
12369     echo "$as_me:$LINENO: result: pre-installed" >&5
12370 echo "${ECHO_T}pre-installed" >&6
12371   fi
12372 else
12373   ok=yes
12374   case " ${configdirs} " in
12375     *" gcc "*) ;;
12376     *) ok=no ;;
12377   esac
12378   case ,${enable_languages}, in
12379     *,fortran,*) ;;
12380     *) ok=no ;;
12381   esac
12382   if test $ok = yes; then
12383     # An in-tree tool is available and we can use it
12384     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12385     echo "$as_me:$LINENO: result: just compiled" >&5
12386 echo "${ECHO_T}just compiled" >&6
12387   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12388     # We already found the complete path
12389     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12390     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12391 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12392   elif test "x$target" = "x$host"; then
12393     # We can use an host tool
12394     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12395     echo "$as_me:$LINENO: result: host tool" >&5
12396 echo "${ECHO_T}host tool" >&6
12397   else
12398     # We need a cross tool
12399     echo "$as_me:$LINENO: result: pre-installed" >&5
12400 echo "${ECHO_T}pre-installed" >&6
12401   fi
12402 fi
12403
12404 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12405 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12406 if test "x${build}" != "x${host}" ; then
12407   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12408     # We already found the complete path
12409     ac_dir=`dirname $LD_FOR_TARGET`
12410     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12411 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12412   else
12413     # Canadian cross, just use what we found
12414     echo "$as_me:$LINENO: result: pre-installed" >&5
12415 echo "${ECHO_T}pre-installed" >&6
12416   fi
12417 else
12418   ok=yes
12419   case " ${configdirs} " in
12420     *" ld "*) ;;
12421     *) ok=no ;;
12422   esac
12423
12424   if test $ok = yes; then
12425     # An in-tree tool is available and we can use it
12426     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12427     echo "$as_me:$LINENO: result: just compiled" >&5
12428 echo "${ECHO_T}just compiled" >&6
12429   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12430     # We already found the complete path
12431     ac_dir=`dirname $LD_FOR_TARGET`
12432     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12433 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12434   elif test "x$target" = "x$host"; then
12435     # We can use an host tool
12436     LD_FOR_TARGET='$(LD)'
12437     echo "$as_me:$LINENO: result: host tool" >&5
12438 echo "${ECHO_T}host tool" >&6
12439   else
12440     # We need a cross tool
12441     echo "$as_me:$LINENO: result: pre-installed" >&5
12442 echo "${ECHO_T}pre-installed" >&6
12443   fi
12444 fi
12445
12446 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12447 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12448 if test "x${build}" != "x${host}" ; then
12449   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12450     # We already found the complete path
12451     ac_dir=`dirname $LIPO_FOR_TARGET`
12452     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12453 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12454   else
12455     # Canadian cross, just use what we found
12456     echo "$as_me:$LINENO: result: pre-installed" >&5
12457 echo "${ECHO_T}pre-installed" >&6
12458   fi
12459 else
12460   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12461     # We already found the complete path
12462     ac_dir=`dirname $LIPO_FOR_TARGET`
12463     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12464 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12465   elif test "x$target" = "x$host"; then
12466     # We can use an host tool
12467     LIPO_FOR_TARGET='$(LIPO)'
12468     echo "$as_me:$LINENO: result: host tool" >&5
12469 echo "${ECHO_T}host tool" >&6
12470   else
12471     # We need a cross tool
12472     echo "$as_me:$LINENO: result: pre-installed" >&5
12473 echo "${ECHO_T}pre-installed" >&6
12474   fi
12475 fi
12476
12477 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12478 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12479 if test "x${build}" != "x${host}" ; then
12480   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12481     # We already found the complete path
12482     ac_dir=`dirname $NM_FOR_TARGET`
12483     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12484 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12485   else
12486     # Canadian cross, just use what we found
12487     echo "$as_me:$LINENO: result: pre-installed" >&5
12488 echo "${ECHO_T}pre-installed" >&6
12489   fi
12490 else
12491   ok=yes
12492   case " ${configdirs} " in
12493     *" binutils "*) ;;
12494     *) ok=no ;;
12495   esac
12496
12497   if test $ok = yes; then
12498     # An in-tree tool is available and we can use it
12499     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12500     echo "$as_me:$LINENO: result: just compiled" >&5
12501 echo "${ECHO_T}just compiled" >&6
12502   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12503     # We already found the complete path
12504     ac_dir=`dirname $NM_FOR_TARGET`
12505     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12506 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12507   elif test "x$target" = "x$host"; then
12508     # We can use an host tool
12509     NM_FOR_TARGET='$(NM)'
12510     echo "$as_me:$LINENO: result: host tool" >&5
12511 echo "${ECHO_T}host tool" >&6
12512   else
12513     # We need a cross tool
12514     echo "$as_me:$LINENO: result: pre-installed" >&5
12515 echo "${ECHO_T}pre-installed" >&6
12516   fi
12517 fi
12518
12519 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12520 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12521 if test "x${build}" != "x${host}" ; then
12522   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12523     # We already found the complete path
12524     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12525     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12526 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12527   else
12528     # Canadian cross, just use what we found
12529     echo "$as_me:$LINENO: result: pre-installed" >&5
12530 echo "${ECHO_T}pre-installed" >&6
12531   fi
12532 else
12533   ok=yes
12534   case " ${configdirs} " in
12535     *" binutils "*) ;;
12536     *) ok=no ;;
12537   esac
12538
12539   if test $ok = yes; then
12540     # An in-tree tool is available and we can use it
12541     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12542     echo "$as_me:$LINENO: result: just compiled" >&5
12543 echo "${ECHO_T}just compiled" >&6
12544   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12545     # We already found the complete path
12546     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12547     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12548 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12549   elif test "x$target" = "x$host"; then
12550     # We can use an host tool
12551     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12552     echo "$as_me:$LINENO: result: host tool" >&5
12553 echo "${ECHO_T}host tool" >&6
12554   else
12555     # We need a cross tool
12556     echo "$as_me:$LINENO: result: pre-installed" >&5
12557 echo "${ECHO_T}pre-installed" >&6
12558   fi
12559 fi
12560
12561 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12562 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12563 if test "x${build}" != "x${host}" ; then
12564   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12565     # We already found the complete path
12566     ac_dir=`dirname $RANLIB_FOR_TARGET`
12567     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12568 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12569   else
12570     # Canadian cross, just use what we found
12571     echo "$as_me:$LINENO: result: pre-installed" >&5
12572 echo "${ECHO_T}pre-installed" >&6
12573   fi
12574 else
12575   ok=yes
12576   case " ${configdirs} " in
12577     *" binutils "*) ;;
12578     *) ok=no ;;
12579   esac
12580
12581   if test $ok = yes; then
12582     # An in-tree tool is available and we can use it
12583     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12584     echo "$as_me:$LINENO: result: just compiled" >&5
12585 echo "${ECHO_T}just compiled" >&6
12586   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12587     # We already found the complete path
12588     ac_dir=`dirname $RANLIB_FOR_TARGET`
12589     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12590 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12591   elif test "x$target" = "x$host"; then
12592     # We can use an host tool
12593     RANLIB_FOR_TARGET='$(RANLIB)'
12594     echo "$as_me:$LINENO: result: host tool" >&5
12595 echo "${ECHO_T}host tool" >&6
12596   else
12597     # We need a cross tool
12598     echo "$as_me:$LINENO: result: pre-installed" >&5
12599 echo "${ECHO_T}pre-installed" >&6
12600   fi
12601 fi
12602
12603 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12604 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12605 if test "x${build}" != "x${host}" ; then
12606   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12607     # We already found the complete path
12608     ac_dir=`dirname $STRIP_FOR_TARGET`
12609     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12610 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12611   else
12612     # Canadian cross, just use what we found
12613     echo "$as_me:$LINENO: result: pre-installed" >&5
12614 echo "${ECHO_T}pre-installed" >&6
12615   fi
12616 else
12617   ok=yes
12618   case " ${configdirs} " in
12619     *" binutils "*) ;;
12620     *) ok=no ;;
12621   esac
12622
12623   if test $ok = yes; then
12624     # An in-tree tool is available and we can use it
12625     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12626     echo "$as_me:$LINENO: result: just compiled" >&5
12627 echo "${ECHO_T}just compiled" >&6
12628   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12629     # We already found the complete path
12630     ac_dir=`dirname $STRIP_FOR_TARGET`
12631     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12632 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12633   elif test "x$target" = "x$host"; then
12634     # We can use an host tool
12635     STRIP_FOR_TARGET='$(STRIP)'
12636     echo "$as_me:$LINENO: result: host tool" >&5
12637 echo "${ECHO_T}host tool" >&6
12638   else
12639     # We need a cross tool
12640     echo "$as_me:$LINENO: result: pre-installed" >&5
12641 echo "${ECHO_T}pre-installed" >&6
12642   fi
12643 fi
12644
12645 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12646 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12647 if test "x${build}" != "x${host}" ; then
12648   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12649     # We already found the complete path
12650     ac_dir=`dirname $WINDRES_FOR_TARGET`
12651     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12652 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12653   else
12654     # Canadian cross, just use what we found
12655     echo "$as_me:$LINENO: result: pre-installed" >&5
12656 echo "${ECHO_T}pre-installed" >&6
12657   fi
12658 else
12659   ok=yes
12660   case " ${configdirs} " in
12661     *" binutils "*) ;;
12662     *) ok=no ;;
12663   esac
12664
12665   if test $ok = yes; then
12666     # An in-tree tool is available and we can use it
12667     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12668     echo "$as_me:$LINENO: result: just compiled" >&5
12669 echo "${ECHO_T}just compiled" >&6
12670   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12671     # We already found the complete path
12672     ac_dir=`dirname $WINDRES_FOR_TARGET`
12673     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12674 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12675   elif test "x$target" = "x$host"; then
12676     # We can use an host tool
12677     WINDRES_FOR_TARGET='$(WINDRES)'
12678     echo "$as_me:$LINENO: result: host tool" >&5
12679 echo "${ECHO_T}host tool" >&6
12680   else
12681     # We need a cross tool
12682     echo "$as_me:$LINENO: result: pre-installed" >&5
12683 echo "${ECHO_T}pre-installed" >&6
12684   fi
12685 fi
12686
12687 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12688 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12689 if test "x${build}" != "x${host}" ; then
12690   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12691     # We already found the complete path
12692     ac_dir=`dirname $WINDMC_FOR_TARGET`
12693     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12694 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12695   else
12696     # Canadian cross, just use what we found
12697     echo "$as_me:$LINENO: result: pre-installed" >&5
12698 echo "${ECHO_T}pre-installed" >&6
12699   fi
12700 else
12701   ok=yes
12702   case " ${configdirs} " in
12703     *" binutils "*) ;;
12704     *) ok=no ;;
12705   esac
12706
12707   if test $ok = yes; then
12708     # An in-tree tool is available and we can use it
12709     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12710     echo "$as_me:$LINENO: result: just compiled" >&5
12711 echo "${ECHO_T}just compiled" >&6
12712   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12713     # We already found the complete path
12714     ac_dir=`dirname $WINDMC_FOR_TARGET`
12715     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12716 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12717   elif test "x$target" = "x$host"; then
12718     # We can use an host tool
12719     WINDMC_FOR_TARGET='$(WINDMC)'
12720     echo "$as_me:$LINENO: result: host tool" >&5
12721 echo "${ECHO_T}host tool" >&6
12722   else
12723     # We need a cross tool
12724     echo "$as_me:$LINENO: result: pre-installed" >&5
12725 echo "${ECHO_T}pre-installed" >&6
12726   fi
12727 fi
12728
12729
12730
12731
12732
12733 # Certain tools may need extra flags.
12734 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12735 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12736 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12737
12738 # When building target libraries, except in a Canadian cross, we use
12739 # the same toolchain as the compiler we just built.
12740 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12741 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12742 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12743 if test $host = $build; then
12744   case " $configdirs " in
12745     *" gcc "*)
12746       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12747       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12748       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12749       ;;
12750   esac
12751 fi
12752
12753
12754
12755
12756
12757 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12758 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12759 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12760 if test "${enable_maintainer_mode+set}" = set; then
12761   enableval="$enable_maintainer_mode"
12762   USE_MAINTAINER_MODE=$enableval
12763 else
12764   USE_MAINTAINER_MODE=no
12765 fi;
12766 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12767 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12768
12769
12770 if test "$USE_MAINTAINER_MODE" = yes; then
12771   MAINTAINER_MODE_TRUE=
12772   MAINTAINER_MODE_FALSE='#'
12773 else
12774   MAINTAINER_MODE_TRUE='#'
12775   MAINTAINER_MODE_FALSE=
12776 fi
12777 MAINT=$MAINTAINER_MODE_TRUE
12778
12779 # ---------------------
12780 # GCC bootstrap support
12781 # ---------------------
12782
12783 # Stage specific cflags for build.
12784 stage1_cflags="-g"
12785 case $build in
12786   vax-*-*)
12787     case ${GCC} in
12788       yes) stage1_cflags="-g -Wa,-J" ;;
12789       *) stage1_cflags="-g -J" ;;
12790     esac ;;
12791 esac
12792
12793 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12794 if test "$GCC" = yes -a "$ENABLE_BUILD_WITH_CXX" != yes; then
12795   saved_CFLAGS="$CFLAGS"
12796
12797   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12798   CFLAGS="$CFLAGS -fkeep-inline-functions"
12799   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12800 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12801   cat >conftest.$ac_ext <<_ACEOF
12802 /* confdefs.h.  */
12803 _ACEOF
12804 cat confdefs.h >>conftest.$ac_ext
12805 cat >>conftest.$ac_ext <<_ACEOF
12806 /* end confdefs.h.  */
12807
12808 #if (__GNUC__ < 3) \
12809     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12810                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12811 #error http://gcc.gnu.org/PR29382
12812 #endif
12813
12814 int
12815 main ()
12816 {
12817
12818   ;
12819   return 0;
12820 }
12821 _ACEOF
12822 rm -f conftest.$ac_objext
12823 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12824   (eval $ac_compile) 2>conftest.er1
12825   ac_status=$?
12826   grep -v '^ *+' conftest.er1 >conftest.err
12827   rm -f conftest.er1
12828   cat conftest.err >&5
12829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12830   (exit $ac_status); } &&
12831          { ac_try='test -z "$ac_c_werror_flag"
12832                          || test ! -s conftest.err'
12833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12834   (eval $ac_try) 2>&5
12835   ac_status=$?
12836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12837   (exit $ac_status); }; } &&
12838          { ac_try='test -s conftest.$ac_objext'
12839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12840   (eval $ac_try) 2>&5
12841   ac_status=$?
12842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12843   (exit $ac_status); }; }; then
12844   echo "$as_me:$LINENO: result: yes" >&5
12845 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12846 else
12847   echo "$as_me: failed program was:" >&5
12848 sed 's/^/| /' conftest.$ac_ext >&5
12849
12850 echo "$as_me:$LINENO: result: no" >&5
12851 echo "${ECHO_T}no" >&6
12852 fi
12853 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12854
12855   CFLAGS="$saved_CFLAGS"
12856 fi
12857
12858
12859
12860 # Enable --enable-checking in stage1 of the compiler.
12861 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12862 if test "${enable_stage1_checking+set}" = set; then
12863   enableval="$enable_stage1_checking"
12864   stage1_checking=--enable-checking=${enable_stage1_checking}
12865 else
12866   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12867   stage1_checking=--enable-checking=yes,types
12868 else
12869   stage1_checking=--enable-checking=$enable_checking,types
12870 fi
12871 fi;
12872
12873
12874 # Enable -Werror in bootstrap stage2 and later.
12875 # Check whether --enable-werror or --disable-werror was given.
12876 if test "${enable_werror+set}" = set; then
12877   enableval="$enable_werror"
12878
12879 else
12880   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12881   enable_werror=yes
12882 else
12883   enable_werror=no
12884 fi
12885 fi;
12886 case ${enable_werror} in
12887   yes) stage2_werror_flag="--enable-werror-always" ;;
12888   *) stage2_werror_flag="" ;;
12889 esac
12890
12891
12892 # Flags needed to enable html installing and building
12893
12894 # Check whether --with-datarootdir or --without-datarootdir was given.
12895 if test "${with_datarootdir+set}" = set; then
12896   withval="$with_datarootdir"
12897   datarootdir="\${prefix}/${withval}"
12898 else
12899   datarootdir="\${prefix}/share"
12900 fi;
12901
12902
12903 # Check whether --with-docdir or --without-docdir was given.
12904 if test "${with_docdir+set}" = set; then
12905   withval="$with_docdir"
12906   docdir="\${prefix}/${withval}"
12907 else
12908   docdir="\${datarootdir}/doc"
12909 fi;
12910
12911
12912 # Check whether --with-pdfdir or --without-pdfdir was given.
12913 if test "${with_pdfdir+set}" = set; then
12914   withval="$with_pdfdir"
12915   pdfdir="\${prefix}/${withval}"
12916 else
12917   pdfdir="\${docdir}"
12918 fi;
12919
12920
12921 # Check whether --with-htmldir or --without-htmldir was given.
12922 if test "${with_htmldir+set}" = set; then
12923   withval="$with_htmldir"
12924   htmldir="\${prefix}/${withval}"
12925 else
12926   htmldir="\${docdir}"
12927 fi;
12928
12929
12930
12931
12932
12933
12934 # Specify what files to not compare during bootstrap.
12935
12936 compare_exclusions="gcc/cc*-checksum\$(objext) | gcc/ada/*tools/*"
12937 case "$target" in
12938   hppa*64*-*-hpux*) ;;
12939   hppa*-*-hpux*) compare_exclusions="gcc/cc*-checksum\$(objext) | */libgcc/lib2funcs* | gcc/ada/*tools/*" ;;
12940 esac
12941
12942
12943           ac_config_files="$ac_config_files Makefile"
12944 cat >confcache <<\_ACEOF
12945 # This file is a shell script that caches the results of configure
12946 # tests run on this system so they can be shared between configure
12947 # scripts and configure runs, see configure's option --config-cache.
12948 # It is not useful on other systems.  If it contains results you don't
12949 # want to keep, you may remove or edit it.
12950 #
12951 # config.status only pays attention to the cache file if you give it
12952 # the --recheck option to rerun configure.
12953 #
12954 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12955 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12956 # following values.
12957
12958 _ACEOF
12959
12960 # The following way of writing the cache mishandles newlines in values,
12961 # but we know of no workaround that is simple, portable, and efficient.
12962 # So, don't put newlines in cache variables' values.
12963 # Ultrix sh set writes to stderr and can't be redirected directly,
12964 # and sets the high bit in the cache file unless we assign to the vars.
12965 {
12966   (set) 2>&1 |
12967     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12968     *ac_space=\ *)
12969       # `set' does not quote correctly, so add quotes (double-quote
12970       # substitution turns \\\\ into \\, and sed turns \\ into \).
12971       sed -n \
12972         "s/'/'\\\\''/g;
12973           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12974       ;;
12975     *)
12976       # `set' quotes correctly as required by POSIX, so do not add quotes.
12977       sed -n \
12978         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12979       ;;
12980     esac;
12981 } |
12982   sed '
12983      t clear
12984      : clear
12985      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12986      t end
12987      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12988      : end' >>confcache
12989 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12990   if test -w $cache_file; then
12991     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12992     cat confcache >$cache_file
12993   else
12994     echo "not updating unwritable cache $cache_file"
12995   fi
12996 fi
12997 rm -f confcache
12998
12999 test "x$prefix" = xNONE && prefix=$ac_default_prefix
13000 # Let make expand exec_prefix.
13001 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
13002
13003 # VPATH may cause trouble with some makes, so we remove $(srcdir),
13004 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
13005 # trailing colons and then remove the whole line if VPATH becomes empty
13006 # (actually we leave an empty line to preserve line numbers).
13007 if test "x$srcdir" = x.; then
13008   ac_vpsub='/^[  ]*VPATH[        ]*=/{
13009 s/:*\$(srcdir):*/:/;
13010 s/:*\${srcdir}:*/:/;
13011 s/:*@srcdir@:*/:/;
13012 s/^\([^=]*=[     ]*\):*/\1/;
13013 s/:*$//;
13014 s/^[^=]*=[       ]*$//;
13015 }'
13016 fi
13017
13018 # Transform confdefs.h into DEFS.
13019 # Protect against shell expansion while executing Makefile rules.
13020 # Protect against Makefile macro expansion.
13021 #
13022 # If the first sed substitution is executed (which looks for macros that
13023 # take arguments), then we branch to the quote section.  Otherwise,
13024 # look for a macro that doesn't take arguments.
13025 cat >confdef2opt.sed <<\_ACEOF
13026 t clear
13027 : clear
13028 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
13029 t quote
13030 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
13031 t quote
13032 d
13033 : quote
13034 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
13035 s,\[,\\&,g
13036 s,\],\\&,g
13037 s,\$,$$,g
13038 p
13039 _ACEOF
13040 # We use echo to avoid assuming a particular line-breaking character.
13041 # The extra dot is to prevent the shell from consuming trailing
13042 # line-breaks from the sub-command output.  A line-break within
13043 # single-quotes doesn't work because, if this script is created in a
13044 # platform that uses two characters for line-breaks (e.g., DOS), tr
13045 # would break.
13046 ac_LF_and_DOT=`echo; echo .`
13047 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
13048 rm -f confdef2opt.sed
13049
13050
13051 ac_libobjs=
13052 ac_ltlibobjs=
13053 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
13054   # 1. Remove the extension, and $U if already installed.
13055   ac_i=`echo "$ac_i" |
13056          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
13057   # 2. Add them.
13058   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
13059   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
13060 done
13061 LIBOBJS=$ac_libobjs
13062
13063 LTLIBOBJS=$ac_ltlibobjs
13064
13065
13066
13067 : ${CONFIG_STATUS=./config.status}
13068 ac_clean_files_save=$ac_clean_files
13069 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
13070 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
13071 echo "$as_me: creating $CONFIG_STATUS" >&6;}
13072 cat >$CONFIG_STATUS <<_ACEOF
13073 #! $SHELL
13074 # Generated by $as_me.
13075 # Run this file to recreate the current configuration.
13076 # Compiler output produced by configure, useful for debugging
13077 # configure, is in config.log if it exists.
13078
13079 debug=false
13080 ac_cs_recheck=false
13081 ac_cs_silent=false
13082 SHELL=\${CONFIG_SHELL-$SHELL}
13083 _ACEOF
13084
13085 cat >>$CONFIG_STATUS <<\_ACEOF
13086 ## --------------------- ##
13087 ## M4sh Initialization.  ##
13088 ## --------------------- ##
13089
13090 # Be Bourne compatible
13091 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
13092   emulate sh
13093   NULLCMD=:
13094   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
13095   # is contrary to our usage.  Disable this feature.
13096   alias -g '${1+"$@"}'='"$@"'
13097 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
13098   set -o posix
13099 fi
13100 DUALCASE=1; export DUALCASE # for MKS sh
13101
13102 # Support unset when possible.
13103 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13104   as_unset=unset
13105 else
13106   as_unset=false
13107 fi
13108
13109
13110 # Work around bugs in pre-3.0 UWIN ksh.
13111 $as_unset ENV MAIL MAILPATH
13112 PS1='$ '
13113 PS2='> '
13114 PS4='+ '
13115
13116 # NLS nuisances.
13117 for as_var in \
13118   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13119   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13120   LC_TELEPHONE LC_TIME
13121 do
13122   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13123     eval $as_var=C; export $as_var
13124   else
13125     $as_unset $as_var
13126   fi
13127 done
13128
13129 # Required to use basename.
13130 if expr a : '\(a\)' >/dev/null 2>&1; then
13131   as_expr=expr
13132 else
13133   as_expr=false
13134 fi
13135
13136 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13137   as_basename=basename
13138 else
13139   as_basename=false
13140 fi
13141
13142
13143 # Name of the executable.
13144 as_me=`$as_basename "$0" ||
13145 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13146          X"$0" : 'X\(//\)$' \| \
13147          X"$0" : 'X\(/\)$' \| \
13148          .     : '\(.\)' 2>/dev/null ||
13149 echo X/"$0" |
13150     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13151           /^X\/\(\/\/\)$/{ s//\1/; q; }
13152           /^X\/\(\/\).*/{ s//\1/; q; }
13153           s/.*/./; q'`
13154
13155
13156 # PATH needs CR, and LINENO needs CR and PATH.
13157 # Avoid depending upon Character Ranges.
13158 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13159 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13160 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13161 as_cr_digits='0123456789'
13162 as_cr_alnum=$as_cr_Letters$as_cr_digits
13163
13164 # The user is always right.
13165 if test "${PATH_SEPARATOR+set}" != set; then
13166   echo "#! /bin/sh" >conf$$.sh
13167   echo  "exit 0"   >>conf$$.sh
13168   chmod +x conf$$.sh
13169   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13170     PATH_SEPARATOR=';'
13171   else
13172     PATH_SEPARATOR=:
13173   fi
13174   rm -f conf$$.sh
13175 fi
13176
13177
13178   as_lineno_1=$LINENO
13179   as_lineno_2=$LINENO
13180   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13181   test "x$as_lineno_1" != "x$as_lineno_2" &&
13182   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13183   # Find who we are.  Look in the path if we contain no path at all
13184   # relative or not.
13185   case $0 in
13186     *[\\/]* ) as_myself=$0 ;;
13187     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13188 for as_dir in $PATH
13189 do
13190   IFS=$as_save_IFS
13191   test -z "$as_dir" && as_dir=.
13192   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13193 done
13194
13195        ;;
13196   esac
13197   # We did not find ourselves, most probably we were run as `sh COMMAND'
13198   # in which case we are not to be found in the path.
13199   if test "x$as_myself" = x; then
13200     as_myself=$0
13201   fi
13202   if test ! -f "$as_myself"; then
13203     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13204 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13205    { (exit 1); exit 1; }; }
13206   fi
13207   case $CONFIG_SHELL in
13208   '')
13209     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13210 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13211 do
13212   IFS=$as_save_IFS
13213   test -z "$as_dir" && as_dir=.
13214   for as_base in sh bash ksh sh5; do
13215          case $as_dir in
13216          /*)
13217            if ("$as_dir/$as_base" -c '
13218   as_lineno_1=$LINENO
13219   as_lineno_2=$LINENO
13220   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13221   test "x$as_lineno_1" != "x$as_lineno_2" &&
13222   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13223              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13224              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13225              CONFIG_SHELL=$as_dir/$as_base
13226              export CONFIG_SHELL
13227              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13228            fi;;
13229          esac
13230        done
13231 done
13232 ;;
13233   esac
13234
13235   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13236   # uniformly replaced by the line number.  The first 'sed' inserts a
13237   # line-number line before each line; the second 'sed' does the real
13238   # work.  The second script uses 'N' to pair each line-number line
13239   # with the numbered line, and appends trailing '-' during
13240   # substitution so that $LINENO is not a special case at line end.
13241   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13242   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13243   sed '=' <$as_myself |
13244     sed '
13245       N
13246       s,$,-,
13247       : loop
13248       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13249       t loop
13250       s,-$,,
13251       s,^['$as_cr_digits']*\n,,
13252     ' >$as_me.lineno &&
13253   chmod +x $as_me.lineno ||
13254     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13255 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13256    { (exit 1); exit 1; }; }
13257
13258   # Don't try to exec as it changes $[0], causing all sort of problems
13259   # (the dirname of $[0] is not the place where we might find the
13260   # original and so on.  Autoconf is especially sensible to this).
13261   . ./$as_me.lineno
13262   # Exit status is that of the last command.
13263   exit
13264 }
13265
13266
13267 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13268   *c*,-n*) ECHO_N= ECHO_C='
13269 ' ECHO_T='      ' ;;
13270   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13271   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13272 esac
13273
13274 if expr a : '\(a\)' >/dev/null 2>&1; then
13275   as_expr=expr
13276 else
13277   as_expr=false
13278 fi
13279
13280 rm -f conf$$ conf$$.exe conf$$.file
13281 echo >conf$$.file
13282 if ln -s conf$$.file conf$$ 2>/dev/null; then
13283   # We could just check for DJGPP; but this test a) works b) is more generic
13284   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13285   if test -f conf$$.exe; then
13286     # Don't use ln at all; we don't have any links
13287     as_ln_s='cp -p'
13288   else
13289     as_ln_s='ln -s'
13290   fi
13291 elif ln conf$$.file conf$$ 2>/dev/null; then
13292   as_ln_s=ln
13293 else
13294   as_ln_s='cp -p'
13295 fi
13296 rm -f conf$$ conf$$.exe conf$$.file
13297
13298 if mkdir -p . 2>/dev/null; then
13299   as_mkdir_p=:
13300 else
13301   test -d ./-p && rmdir ./-p
13302   as_mkdir_p=false
13303 fi
13304
13305 as_executable_p="test -f"
13306
13307 # Sed expression to map a string onto a valid CPP name.
13308 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13309
13310 # Sed expression to map a string onto a valid variable name.
13311 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13312
13313
13314 # IFS
13315 # We need space, tab and new line, in precisely that order.
13316 as_nl='
13317 '
13318 IFS="   $as_nl"
13319
13320 # CDPATH.
13321 $as_unset CDPATH
13322
13323 exec 6>&1
13324
13325 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13326 # report actual input values of CONFIG_FILES etc. instead of their
13327 # values after options handling.  Logging --version etc. is OK.
13328 exec 5>>config.log
13329 {
13330   echo
13331   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13332 ## Running $as_me. ##
13333 _ASBOX
13334 } >&5
13335 cat >&5 <<_CSEOF
13336
13337 This file was extended by $as_me, which was
13338 generated by GNU Autoconf 2.59.  Invocation command line was
13339
13340   CONFIG_FILES    = $CONFIG_FILES
13341   CONFIG_HEADERS  = $CONFIG_HEADERS
13342   CONFIG_LINKS    = $CONFIG_LINKS
13343   CONFIG_COMMANDS = $CONFIG_COMMANDS
13344   $ $0 $@
13345
13346 _CSEOF
13347 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13348 echo >&5
13349 _ACEOF
13350
13351 # Files that config.status was made for.
13352 if test -n "$ac_config_files"; then
13353   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13354 fi
13355
13356 if test -n "$ac_config_headers"; then
13357   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13358 fi
13359
13360 if test -n "$ac_config_links"; then
13361   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13362 fi
13363
13364 if test -n "$ac_config_commands"; then
13365   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13366 fi
13367
13368 cat >>$CONFIG_STATUS <<\_ACEOF
13369
13370 ac_cs_usage="\
13371 \`$as_me' instantiates files from templates according to the
13372 current configuration.
13373
13374 Usage: $0 [OPTIONS] [FILE]...
13375
13376   -h, --help       print this help, then exit
13377   -V, --version    print version number, then exit
13378   -q, --quiet      do not print progress messages
13379   -d, --debug      don't remove temporary files
13380       --recheck    update $as_me by reconfiguring in the same conditions
13381   --file=FILE[:TEMPLATE]
13382                    instantiate the configuration file FILE
13383
13384 Configuration files:
13385 $config_files
13386
13387 Report bugs to <bug-autoconf@gnu.org>."
13388 _ACEOF
13389
13390 cat >>$CONFIG_STATUS <<_ACEOF
13391 ac_cs_version="\\
13392 config.status
13393 configured by $0, generated by GNU Autoconf 2.59,
13394   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13395
13396 Copyright (C) 2003 Free Software Foundation, Inc.
13397 This config.status script is free software; the Free Software Foundation
13398 gives unlimited permission to copy, distribute and modify it."
13399 srcdir=$srcdir
13400 INSTALL="$INSTALL"
13401 _ACEOF
13402
13403 cat >>$CONFIG_STATUS <<\_ACEOF
13404 # If no file are specified by the user, then we need to provide default
13405 # value.  By we need to know if files were specified by the user.
13406 ac_need_defaults=:
13407 while test $# != 0
13408 do
13409   case $1 in
13410   --*=*)
13411     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13412     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13413     ac_shift=:
13414     ;;
13415   -*)
13416     ac_option=$1
13417     ac_optarg=$2
13418     ac_shift=shift
13419     ;;
13420   *) # This is not an option, so the user has probably given explicit
13421      # arguments.
13422      ac_option=$1
13423      ac_need_defaults=false;;
13424   esac
13425
13426   case $ac_option in
13427   # Handling of the options.
13428 _ACEOF
13429 cat >>$CONFIG_STATUS <<\_ACEOF
13430   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13431     ac_cs_recheck=: ;;
13432   --version | --vers* | -V )
13433     echo "$ac_cs_version"; exit 0 ;;
13434   --he | --h)
13435     # Conflict between --help and --header
13436     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13437 Try \`$0 --help' for more information." >&5
13438 echo "$as_me: error: ambiguous option: $1
13439 Try \`$0 --help' for more information." >&2;}
13440    { (exit 1); exit 1; }; };;
13441   --help | --hel | -h )
13442     echo "$ac_cs_usage"; exit 0 ;;
13443   --debug | --d* | -d )
13444     debug=: ;;
13445   --file | --fil | --fi | --f )
13446     $ac_shift
13447     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13448     ac_need_defaults=false;;
13449   --header | --heade | --head | --hea )
13450     $ac_shift
13451     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13452     ac_need_defaults=false;;
13453   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13454   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13455     ac_cs_silent=: ;;
13456
13457   # This is an error.
13458   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13459 Try \`$0 --help' for more information." >&5
13460 echo "$as_me: error: unrecognized option: $1
13461 Try \`$0 --help' for more information." >&2;}
13462    { (exit 1); exit 1; }; } ;;
13463
13464   *) ac_config_targets="$ac_config_targets $1" ;;
13465
13466   esac
13467   shift
13468 done
13469
13470 ac_configure_extra_args=
13471
13472 if $ac_cs_silent; then
13473   exec 6>/dev/null
13474   ac_configure_extra_args="$ac_configure_extra_args --silent"
13475 fi
13476
13477 _ACEOF
13478 cat >>$CONFIG_STATUS <<_ACEOF
13479 if \$ac_cs_recheck; then
13480   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13481   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13482 fi
13483
13484 _ACEOF
13485
13486
13487
13488
13489
13490 cat >>$CONFIG_STATUS <<\_ACEOF
13491 for ac_config_target in $ac_config_targets
13492 do
13493   case "$ac_config_target" in
13494   # Handling of arguments.
13495   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13496   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13497 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13498    { (exit 1); exit 1; }; };;
13499   esac
13500 done
13501
13502 # If the user did not use the arguments to specify the items to instantiate,
13503 # then the envvar interface is used.  Set only those that are not.
13504 # We use the long form for the default assignment because of an extremely
13505 # bizarre bug on SunOS 4.1.3.
13506 if $ac_need_defaults; then
13507   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13508 fi
13509
13510 # Have a temporary directory for convenience.  Make it in the build tree
13511 # simply because there is no reason to put it here, and in addition,
13512 # creating and moving files from /tmp can sometimes cause problems.
13513 # Create a temporary directory, and hook for its removal unless debugging.
13514 $debug ||
13515 {
13516   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13517   trap '{ (exit 1); exit 1; }' 1 2 13 15
13518 }
13519
13520 # Create a (secure) tmp directory for tmp files.
13521
13522 {
13523   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13524   test -n "$tmp" && test -d "$tmp"
13525 }  ||
13526 {
13527   tmp=./confstat$$-$RANDOM
13528   (umask 077 && mkdir $tmp)
13529 } ||
13530 {
13531    echo "$me: cannot create a temporary directory in ." >&2
13532    { (exit 1); exit 1; }
13533 }
13534
13535 _ACEOF
13536
13537 cat >>$CONFIG_STATUS <<_ACEOF
13538
13539 #
13540 # CONFIG_FILES section.
13541 #
13542
13543 # No need to generate the scripts if there are no CONFIG_FILES.
13544 # This happens for instance when ./config.status config.h
13545 if test -n "\$CONFIG_FILES"; then
13546   # Protect against being on the right side of a sed subst in config.status.
13547   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13548    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13549 s,@SHELL@,$SHELL,;t t
13550 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13551 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13552 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13553 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13554 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13555 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13556 s,@exec_prefix@,$exec_prefix,;t t
13557 s,@prefix@,$prefix,;t t
13558 s,@program_transform_name@,$program_transform_name,;t t
13559 s,@bindir@,$bindir,;t t
13560 s,@sbindir@,$sbindir,;t t
13561 s,@libexecdir@,$libexecdir,;t t
13562 s,@datadir@,$datadir,;t t
13563 s,@sysconfdir@,$sysconfdir,;t t
13564 s,@sharedstatedir@,$sharedstatedir,;t t
13565 s,@localstatedir@,$localstatedir,;t t
13566 s,@libdir@,$libdir,;t t
13567 s,@includedir@,$includedir,;t t
13568 s,@oldincludedir@,$oldincludedir,;t t
13569 s,@infodir@,$infodir,;t t
13570 s,@mandir@,$mandir,;t t
13571 s,@build_alias@,$build_alias,;t t
13572 s,@host_alias@,$host_alias,;t t
13573 s,@target_alias@,$target_alias,;t t
13574 s,@DEFS@,$DEFS,;t t
13575 s,@ECHO_C@,$ECHO_C,;t t
13576 s,@ECHO_N@,$ECHO_N,;t t
13577 s,@ECHO_T@,$ECHO_T,;t t
13578 s,@LIBS@,$LIBS,;t t
13579 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13580 s,@build@,$build,;t t
13581 s,@build_cpu@,$build_cpu,;t t
13582 s,@build_vendor@,$build_vendor,;t t
13583 s,@build_os@,$build_os,;t t
13584 s,@build_noncanonical@,$build_noncanonical,;t t
13585 s,@host_noncanonical@,$host_noncanonical,;t t
13586 s,@target_noncanonical@,$target_noncanonical,;t t
13587 s,@host@,$host,;t t
13588 s,@host_cpu@,$host_cpu,;t t
13589 s,@host_vendor@,$host_vendor,;t t
13590 s,@host_os@,$host_os,;t t
13591 s,@target@,$target,;t t
13592 s,@target_cpu@,$target_cpu,;t t
13593 s,@target_vendor@,$target_vendor,;t t
13594 s,@target_os@,$target_os,;t t
13595 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13596 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13597 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13598 s,@LN@,$LN,;t t
13599 s,@LN_S@,$LN_S,;t t
13600 s,@build_libsubdir@,$build_libsubdir,;t t
13601 s,@build_subdir@,$build_subdir,;t t
13602 s,@host_subdir@,$host_subdir,;t t
13603 s,@target_subdir@,$target_subdir,;t t
13604 s,@CC@,$CC,;t t
13605 s,@CFLAGS@,$CFLAGS,;t t
13606 s,@LDFLAGS@,$LDFLAGS,;t t
13607 s,@CPPFLAGS@,$CPPFLAGS,;t t
13608 s,@ac_ct_CC@,$ac_ct_CC,;t t
13609 s,@EXEEXT@,$EXEEXT,;t t
13610 s,@OBJEXT@,$OBJEXT,;t t
13611 s,@CXX@,$CXX,;t t
13612 s,@CXXFLAGS@,$CXXFLAGS,;t t
13613 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13614 s,@GNATBIND@,$GNATBIND,;t t
13615 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13616 s,@GNATMAKE@,$GNATMAKE,;t t
13617 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13618 s,@do_compare@,$do_compare,;t t
13619 s,@gmplibs@,$gmplibs,;t t
13620 s,@gmpinc@,$gmpinc,;t t
13621 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13622 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13623 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13624 s,@stage1_ldflags@,$stage1_ldflags,;t t
13625 s,@stage1_libs@,$stage1_libs,;t t
13626 s,@poststage1_ldflags@,$poststage1_ldflags,;t t
13627 s,@poststage1_libs@,$poststage1_libs,;t t
13628 s,@ppllibs@,$ppllibs,;t t
13629 s,@pplinc@,$pplinc,;t t
13630 s,@clooglibs@,$clooglibs,;t t
13631 s,@clooginc@,$clooginc,;t t
13632 s,@stage1_languages@,$stage1_languages,;t t
13633 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13634 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13635 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13636 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13637 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13638 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13639 s,@tooldir@,$tooldir,;t t
13640 s,@build_tooldir@,$build_tooldir,;t t
13641 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13642 s,@GDB_TK@,$GDB_TK,;t t
13643 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13644 s,@build_configargs@,$build_configargs,;t t
13645 s,@build_configdirs@,$build_configdirs,;t t
13646 s,@host_configargs@,$host_configargs,;t t
13647 s,@configdirs@,$configdirs,;t t
13648 s,@target_configargs@,$target_configargs,;t t
13649 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13650 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13651 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13652 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13653 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13654 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13655 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13656 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13657 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13658 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13659 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13660 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13661 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13662 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13663 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13664 s,@config_shell@,$config_shell,;t t
13665 s,@YACC@,$YACC,;t t
13666 s,@BISON@,$BISON,;t t
13667 s,@M4@,$M4,;t t
13668 s,@LEX@,$LEX,;t t
13669 s,@FLEX@,$FLEX,;t t
13670 s,@MAKEINFO@,$MAKEINFO,;t t
13671 s,@EXPECT@,$EXPECT,;t t
13672 s,@RUNTEST@,$RUNTEST,;t t
13673 s,@AR@,$AR,;t t
13674 s,@AS@,$AS,;t t
13675 s,@DLLTOOL@,$DLLTOOL,;t t
13676 s,@LD@,$LD,;t t
13677 s,@LIPO@,$LIPO,;t t
13678 s,@NM@,$NM,;t t
13679 s,@RANLIB@,$RANLIB,;t t
13680 s,@STRIP@,$STRIP,;t t
13681 s,@WINDRES@,$WINDRES,;t t
13682 s,@WINDMC@,$WINDMC,;t t
13683 s,@OBJCOPY@,$OBJCOPY,;t t
13684 s,@OBJDUMP@,$OBJDUMP,;t t
13685 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13686 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13687 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13688 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13689 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13690 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13691 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13692 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13693 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13694 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13695 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13696 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13697 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13698 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13699 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13700 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13701 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13702 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13703 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13704 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13705 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13706 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13707 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13708 s,@MAINT@,$MAINT,;t t
13709 s,@stage1_cflags@,$stage1_cflags,;t t
13710 s,@stage1_checking@,$stage1_checking,;t t
13711 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13712 s,@datarootdir@,$datarootdir,;t t
13713 s,@docdir@,$docdir,;t t
13714 s,@pdfdir@,$pdfdir,;t t
13715 s,@htmldir@,$htmldir,;t t
13716 s,@compare_exclusions@,$compare_exclusions,;t t
13717 s,@LIBOBJS@,$LIBOBJS,;t t
13718 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13719 /@serialization_dependencies@/r $serialization_dependencies
13720 s,@serialization_dependencies@,,;t t
13721 /@host_makefile_frag@/r $host_makefile_frag
13722 s,@host_makefile_frag@,,;t t
13723 /@target_makefile_frag@/r $target_makefile_frag
13724 s,@target_makefile_frag@,,;t t
13725 /@alphaieee_frag@/r $alphaieee_frag
13726 s,@alphaieee_frag@,,;t t
13727 /@ospace_frag@/r $ospace_frag
13728 s,@ospace_frag@,,;t t
13729 CEOF
13730
13731 _ACEOF
13732
13733   cat >>$CONFIG_STATUS <<\_ACEOF
13734   # Split the substitutions into bite-sized pieces for seds with
13735   # small command number limits, like on Digital OSF/1 and HP-UX.
13736   ac_max_sed_lines=48
13737   ac_sed_frag=1 # Number of current file.
13738   ac_beg=1 # First line for current file.
13739   ac_end=$ac_max_sed_lines # Line after last line for current file.
13740   ac_more_lines=:
13741   ac_sed_cmds=
13742   while $ac_more_lines; do
13743     if test $ac_beg -gt 1; then
13744       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13745     else
13746       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13747     fi
13748     if test ! -s $tmp/subs.frag; then
13749       ac_more_lines=false
13750     else
13751       # The purpose of the label and of the branching condition is to
13752       # speed up the sed processing (if there are no `@' at all, there
13753       # is no need to browse any of the substitutions).
13754       # These are the two extra sed commands mentioned above.
13755       (echo ':t
13756   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13757       if test -z "$ac_sed_cmds"; then
13758         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13759       else
13760         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13761       fi
13762       ac_sed_frag=`expr $ac_sed_frag + 1`
13763       ac_beg=$ac_end
13764       ac_end=`expr $ac_end + $ac_max_sed_lines`
13765     fi
13766   done
13767   if test -z "$ac_sed_cmds"; then
13768     ac_sed_cmds=cat
13769   fi
13770 fi # test -n "$CONFIG_FILES"
13771
13772 _ACEOF
13773 cat >>$CONFIG_STATUS <<\_ACEOF
13774 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13775   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13776   case $ac_file in
13777   - | *:- | *:-:* ) # input from stdin
13778         cat >$tmp/stdin
13779         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13780         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13781   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13782         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13783   * )   ac_file_in=$ac_file.in ;;
13784   esac
13785
13786   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13787   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13788 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13789          X"$ac_file" : 'X\(//\)[^/]' \| \
13790          X"$ac_file" : 'X\(//\)$' \| \
13791          X"$ac_file" : 'X\(/\)' \| \
13792          .     : '\(.\)' 2>/dev/null ||
13793 echo X"$ac_file" |
13794     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13795           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13796           /^X\(\/\/\)$/{ s//\1/; q; }
13797           /^X\(\/\).*/{ s//\1/; q; }
13798           s/.*/./; q'`
13799   { if $as_mkdir_p; then
13800     mkdir -p "$ac_dir"
13801   else
13802     as_dir="$ac_dir"
13803     as_dirs=
13804     while test ! -d "$as_dir"; do
13805       as_dirs="$as_dir $as_dirs"
13806       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13807 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13808          X"$as_dir" : 'X\(//\)[^/]' \| \
13809          X"$as_dir" : 'X\(//\)$' \| \
13810          X"$as_dir" : 'X\(/\)' \| \
13811          .     : '\(.\)' 2>/dev/null ||
13812 echo X"$as_dir" |
13813     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13814           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13815           /^X\(\/\/\)$/{ s//\1/; q; }
13816           /^X\(\/\).*/{ s//\1/; q; }
13817           s/.*/./; q'`
13818     done
13819     test ! -n "$as_dirs" || mkdir $as_dirs
13820   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13821 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13822    { (exit 1); exit 1; }; }; }
13823
13824   ac_builddir=.
13825
13826 if test "$ac_dir" != .; then
13827   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13828   # A "../" for each directory in $ac_dir_suffix.
13829   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13830 else
13831   ac_dir_suffix= ac_top_builddir=
13832 fi
13833
13834 case $srcdir in
13835   .)  # No --srcdir option.  We are building in place.
13836     ac_srcdir=.
13837     if test -z "$ac_top_builddir"; then
13838        ac_top_srcdir=.
13839     else
13840        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13841     fi ;;
13842   [\\/]* | ?:[\\/]* )  # Absolute path.
13843     ac_srcdir=$srcdir$ac_dir_suffix;
13844     ac_top_srcdir=$srcdir ;;
13845   *) # Relative path.
13846     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13847     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13848 esac
13849
13850 # Do not use `cd foo && pwd` to compute absolute paths, because
13851 # the directories may not exist.
13852 case `pwd` in
13853 .) ac_abs_builddir="$ac_dir";;
13854 *)
13855   case "$ac_dir" in
13856   .) ac_abs_builddir=`pwd`;;
13857   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13858   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13859   esac;;
13860 esac
13861 case $ac_abs_builddir in
13862 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13863 *)
13864   case ${ac_top_builddir}. in
13865   .) ac_abs_top_builddir=$ac_abs_builddir;;
13866   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13867   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13868   esac;;
13869 esac
13870 case $ac_abs_builddir in
13871 .) ac_abs_srcdir=$ac_srcdir;;
13872 *)
13873   case $ac_srcdir in
13874   .) ac_abs_srcdir=$ac_abs_builddir;;
13875   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13876   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13877   esac;;
13878 esac
13879 case $ac_abs_builddir in
13880 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13881 *)
13882   case $ac_top_srcdir in
13883   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13884   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13885   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13886   esac;;
13887 esac
13888
13889
13890   case $INSTALL in
13891   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13892   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13893   esac
13894
13895   if test x"$ac_file" != x-; then
13896     { echo "$as_me:$LINENO: creating $ac_file" >&5
13897 echo "$as_me: creating $ac_file" >&6;}
13898     rm -f "$ac_file"
13899   fi
13900   # Let's still pretend it is `configure' which instantiates (i.e., don't
13901   # use $as_me), people would be surprised to read:
13902   #    /* config.h.  Generated by config.status.  */
13903   if test x"$ac_file" = x-; then
13904     configure_input=
13905   else
13906     configure_input="$ac_file.  "
13907   fi
13908   configure_input=$configure_input"Generated from `echo $ac_file_in |
13909                                      sed 's,.*/,,'` by configure."
13910
13911   # First look for the input files in the build tree, otherwise in the
13912   # src tree.
13913   ac_file_inputs=`IFS=:
13914     for f in $ac_file_in; do
13915       case $f in
13916       -) echo $tmp/stdin ;;
13917       [\\/$]*)
13918          # Absolute (can't be DOS-style, as IFS=:)
13919          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13920 echo "$as_me: error: cannot find input file: $f" >&2;}
13921    { (exit 1); exit 1; }; }
13922          echo "$f";;
13923       *) # Relative
13924          if test -f "$f"; then
13925            # Build tree
13926            echo "$f"
13927          elif test -f "$srcdir/$f"; then
13928            # Source tree
13929            echo "$srcdir/$f"
13930          else
13931            # /dev/null tree
13932            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13933 echo "$as_me: error: cannot find input file: $f" >&2;}
13934    { (exit 1); exit 1; }; }
13935          fi;;
13936       esac
13937     done` || { (exit 1); exit 1; }
13938 _ACEOF
13939 cat >>$CONFIG_STATUS <<_ACEOF
13940   sed "$ac_vpsub
13941 $extrasub
13942 _ACEOF
13943 cat >>$CONFIG_STATUS <<\_ACEOF
13944 :t
13945 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13946 s,@configure_input@,$configure_input,;t t
13947 s,@srcdir@,$ac_srcdir,;t t
13948 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13949 s,@top_srcdir@,$ac_top_srcdir,;t t
13950 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13951 s,@builddir@,$ac_builddir,;t t
13952 s,@abs_builddir@,$ac_abs_builddir,;t t
13953 s,@top_builddir@,$ac_top_builddir,;t t
13954 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13955 s,@INSTALL@,$ac_INSTALL,;t t
13956 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13957   rm -f $tmp/stdin
13958   if test x"$ac_file" != x-; then
13959     mv $tmp/out $ac_file
13960   else
13961     cat $tmp/out
13962     rm -f $tmp/out
13963   fi
13964
13965 done
13966 _ACEOF
13967
13968 cat >>$CONFIG_STATUS <<\_ACEOF
13969
13970 { (exit 0); exit 0; }
13971 _ACEOF
13972 chmod +x $CONFIG_STATUS
13973 ac_clean_files=$ac_clean_files_save
13974
13975
13976 # configure is writing to config.log, and then calls config.status.
13977 # config.status does its own redirection, appending to config.log.
13978 # Unfortunately, on DOS this fails, as config.log is still kept open
13979 # by configure, so config.status won't be able to write to it; its
13980 # output is simply discarded.  So we exec the FD to /dev/null,
13981 # effectively closing config.log, so it can be properly (re)opened and
13982 # appended to by config.status.  When coming back to configure, we
13983 # need to make the FD available again.
13984 if test "$no_create" != yes; then
13985   ac_cs_success=:
13986   ac_config_status_args=
13987   test "$silent" = yes &&
13988     ac_config_status_args="$ac_config_status_args --quiet"
13989   exec 5>/dev/null
13990   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13991   exec 5>>config.log
13992   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13993   # would make configure fail if this is the last instruction.
13994   $ac_cs_success || { (exit 1); exit 1; }
13995 fi
13996