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
1515 progname=$0
1516 # if PWD already has a value, it is probably wrong.
1517 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1518
1519 # Export original configure arguments for use by sub-configures.
1520 # Quote arguments with shell meta charatcers.
1521 TOPLEVEL_CONFIGURE_ARGUMENTS=
1522 set -- "$progname" "$@"
1523 for ac_arg
1524 do
1525   case "$ac_arg" in
1526   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1527     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1528     # if the argument is of the form -foo=baz, quote the baz part only
1529     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1530   *) ;;
1531   esac
1532   # Add the quoted argument to the list.
1533   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1534 done
1535 if test "$silent" = yes; then
1536   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1537 fi
1538 # Remove the initial space we just introduced and, as these will be
1539 # expanded by make, quote '$'.
1540 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1541
1542
1543 # Find the build, host, and target systems.
1544 ac_aux_dir=
1545 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1546   if test -f $ac_dir/install-sh; then
1547     ac_aux_dir=$ac_dir
1548     ac_install_sh="$ac_aux_dir/install-sh -c"
1549     break
1550   elif test -f $ac_dir/install.sh; then
1551     ac_aux_dir=$ac_dir
1552     ac_install_sh="$ac_aux_dir/install.sh -c"
1553     break
1554   elif test -f $ac_dir/shtool; then
1555     ac_aux_dir=$ac_dir
1556     ac_install_sh="$ac_aux_dir/shtool install -c"
1557     break
1558   fi
1559 done
1560 if test -z "$ac_aux_dir"; then
1561   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1562 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1563    { (exit 1); exit 1; }; }
1564 fi
1565 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1566 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1567 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1568
1569 # Make sure we can run config.sub.
1570 $ac_config_sub sun4 >/dev/null 2>&1 ||
1571   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1572 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1573    { (exit 1); exit 1; }; }
1574
1575 echo "$as_me:$LINENO: checking build system type" >&5
1576 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1577 if test "${ac_cv_build+set}" = set; then
1578   echo $ECHO_N "(cached) $ECHO_C" >&6
1579 else
1580   ac_cv_build_alias=$build_alias
1581 test -z "$ac_cv_build_alias" &&
1582   ac_cv_build_alias=`$ac_config_guess`
1583 test -z "$ac_cv_build_alias" &&
1584   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1585 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1586    { (exit 1); exit 1; }; }
1587 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1588   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1589 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1590    { (exit 1); exit 1; }; }
1591
1592 fi
1593 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1594 echo "${ECHO_T}$ac_cv_build" >&6
1595 build=$ac_cv_build
1596 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1597 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1598 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1599
1600
1601  case ${build_alias} in
1602   "") build_noncanonical=${build} ;;
1603   *) build_noncanonical=${build_alias} ;;
1604 esac
1605
1606
1607
1608  case ${host_alias} in
1609   "") host_noncanonical=${build_noncanonical} ;;
1610   *) host_noncanonical=${host_alias} ;;
1611 esac
1612
1613
1614
1615  case ${target_alias} in
1616   "") target_noncanonical=${host_noncanonical} ;;
1617   *) target_noncanonical=${target_alias} ;;
1618 esac
1619
1620
1621
1622
1623 test "$host_noncanonical" = "$target_noncanonical" &&
1624   test "$program_prefix$program_suffix$program_transform_name" = \
1625     NONENONEs,x,x, &&
1626   program_transform_name=s,y,y,
1627
1628 echo "$as_me:$LINENO: checking host system type" >&5
1629 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1630 if test "${ac_cv_host+set}" = set; then
1631   echo $ECHO_N "(cached) $ECHO_C" >&6
1632 else
1633   ac_cv_host_alias=$host_alias
1634 test -z "$ac_cv_host_alias" &&
1635   ac_cv_host_alias=$ac_cv_build_alias
1636 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1637   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1638 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1639    { (exit 1); exit 1; }; }
1640
1641 fi
1642 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1643 echo "${ECHO_T}$ac_cv_host" >&6
1644 host=$ac_cv_host
1645 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1646 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1647 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1648
1649
1650 echo "$as_me:$LINENO: checking target system type" >&5
1651 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1652 if test "${ac_cv_target+set}" = set; then
1653   echo $ECHO_N "(cached) $ECHO_C" >&6
1654 else
1655   ac_cv_target_alias=$target_alias
1656 test "x$ac_cv_target_alias" = "x" &&
1657   ac_cv_target_alias=$ac_cv_host_alias
1658 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1659   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1660 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1661    { (exit 1); exit 1; }; }
1662
1663 fi
1664 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1665 echo "${ECHO_T}$ac_cv_target" >&6
1666 target=$ac_cv_target
1667 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1668 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1669 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1670
1671
1672 # The aliases save the names the user supplied, while $host etc.
1673 # will get canonicalized.
1674 test -n "$target_alias" &&
1675   test "$program_prefix$program_suffix$program_transform_name" = \
1676     NONENONEs,x,x, &&
1677   program_prefix=${target_alias}-
1678 test "$program_prefix" != NONE &&
1679   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1680 # Use a double $ so make ignores it.
1681 test "$program_suffix" != NONE &&
1682   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1683 # Double any \ or $.  echo might interpret backslashes.
1684 # By default was `s,x,x', remove it if useless.
1685 cat <<\_ACEOF >conftest.sed
1686 s/[\\$]/&&/g;s/;s,x,x,$//
1687 _ACEOF
1688 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1689 rm conftest.sed
1690
1691
1692
1693 # Get 'install' or 'install-sh' and its variants.
1694 # Find a good install program.  We prefer a C program (faster),
1695 # so one script is as good as another.  But avoid the broken or
1696 # incompatible versions:
1697 # SysV /etc/install, /usr/sbin/install
1698 # SunOS /usr/etc/install
1699 # IRIX /sbin/install
1700 # AIX /bin/install
1701 # AmigaOS /C/install, which installs bootblocks on floppy discs
1702 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1703 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1704 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1705 # OS/2's system install, which has a completely different semantic
1706 # ./install, which can be erroneously created by make from ./install.sh.
1707 # Reject install programs that cannot install multiple files.
1708 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1709 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1710 if test -z "$INSTALL"; then
1711 if test "${ac_cv_path_install+set}" = set; then
1712   echo $ECHO_N "(cached) $ECHO_C" >&6
1713 else
1714   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1715 for as_dir in $PATH
1716 do
1717   IFS=$as_save_IFS
1718   test -z "$as_dir" && as_dir=.
1719   # Account for people who put trailing slashes in PATH elements.
1720 case $as_dir/ in
1721   ./ | .// | /cC/* | \
1722   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1723   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1724   /usr/ucb/* ) ;;
1725   *)
1726     # OSF1 and SCO ODT 3.0 have their own names for install.
1727     # Don't use installbsd from OSF since it installs stuff as root
1728     # by default.
1729     for ac_prog in ginstall scoinst install; do
1730       for ac_exec_ext in '' $ac_executable_extensions; do
1731         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1732           if test $ac_prog = install &&
1733             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1734             # AIX install.  It has an incompatible calling convention.
1735             :
1736           elif test $ac_prog = install &&
1737             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1738             # program-specific install script used by HP pwplus--don't use.
1739             :
1740           else
1741             rm -rf conftest.one conftest.two conftest.dir
1742             echo one > conftest.one
1743             echo two > conftest.two
1744             mkdir conftest.dir
1745             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1746               test -s conftest.one && test -s conftest.two &&
1747               test -s conftest.dir/conftest.one &&
1748               test -s conftest.dir/conftest.two
1749             then
1750               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1751               break 3
1752             fi
1753           fi
1754         fi
1755       done
1756     done
1757     ;;
1758 esac
1759 done
1760
1761 rm -rf conftest.one conftest.two conftest.dir
1762
1763 fi
1764   if test "${ac_cv_path_install+set}" = set; then
1765     INSTALL=$ac_cv_path_install
1766   else
1767     # As a last resort, use the slow shell script.  Don't cache a
1768     # value for INSTALL within a source directory, because that will
1769     # break other packages using the cache if that directory is
1770     # removed, or if the value is a relative name.
1771     INSTALL=$ac_install_sh
1772   fi
1773 fi
1774 echo "$as_me:$LINENO: result: $INSTALL" >&5
1775 echo "${ECHO_T}$INSTALL" >&6
1776
1777 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1778 # It thinks the first close brace ends the variable substitution.
1779 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1780
1781 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1782
1783 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1784
1785 echo "$as_me:$LINENO: checking whether ln works" >&5
1786 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1787 if test "${acx_cv_prog_LN+set}" = set; then
1788   echo $ECHO_N "(cached) $ECHO_C" >&6
1789 else
1790   rm -f conftestdata_t
1791 echo >conftestdata_f
1792 if ln conftestdata_f conftestdata_t 2>/dev/null
1793 then
1794   acx_cv_prog_LN=ln
1795 else
1796   acx_cv_prog_LN=no
1797 fi
1798 rm -f conftestdata_f conftestdata_t
1799
1800 fi
1801 if test $acx_cv_prog_LN = no; then
1802   LN="cp"
1803   echo "$as_me:$LINENO: result: no, using $LN" >&5
1804 echo "${ECHO_T}no, using $LN" >&6
1805 else
1806   LN="$acx_cv_prog_LN"
1807   echo "$as_me:$LINENO: result: yes" >&5
1808 echo "${ECHO_T}yes" >&6
1809 fi
1810
1811 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1812 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1813 LN_S=$as_ln_s
1814 if test "$LN_S" = "ln -s"; then
1815   echo "$as_me:$LINENO: result: yes" >&5
1816 echo "${ECHO_T}yes" >&6
1817 else
1818   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1819 echo "${ECHO_T}no, using $LN_S" >&6
1820 fi
1821
1822
1823 ### we might need to use some other shell than /bin/sh for running subshells
1824 ### If we are on Windows, search for the shell.  This will permit people
1825 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1826 ### without also having to set CONFIG_SHELL.  This code will work when
1827 ### using bash, which sets OSTYPE.
1828 case "${OSTYPE}" in
1829 *win32*)
1830   if test x${CONFIG_SHELL} = x ; then
1831     if test ! -f /bin/sh ; then
1832       if test x${SHELL} != x && test -f ${SHELL} ; then
1833         CONFIG_SHELL=${SHELL}
1834         export CONFIG_SHELL
1835       else
1836         for prog in sh sh.exe bash bash.exe; do
1837           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1838           for dir in $PATH; do
1839             test -z "$dir" && dir=.
1840             if test -f $dir/$prog; then
1841               CONFIG_SHELL=$dir/$prog
1842               export CONFIG_SHELL
1843               break
1844             fi
1845           done
1846           IFS="$save_ifs"
1847           test -n "${CONFIG_SHELL}" && break
1848         done
1849       fi
1850     fi
1851   fi
1852   ;;
1853 esac
1854
1855 config_shell=${CONFIG_SHELL-/bin/sh}
1856
1857 moveifchange=${srcdir}/move-if-change
1858
1859 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1860
1861 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1862 # a relative path.
1863 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1864   INSTALL="${srcpwd}/install-sh -c"
1865 fi
1866
1867 # Set srcdir to "." if that's what it is.
1868 # This is important for multilib support.
1869 pwd=`${PWDCMD-pwd}`
1870 if test "${pwd}" = "${srcpwd}" ; then
1871   srcdir=.
1872 fi
1873
1874 topsrcdir=$srcpwd
1875
1876 extra_host_args=
1877
1878 ### To add a new directory to the tree, first choose whether it is a target
1879 ### or a host dependent tool.  Then put it into the appropriate list
1880 ### (library or tools, host or target), doing a dependency sort.
1881
1882 # Subdirs will be configured in the order listed in build_configdirs,
1883 # configdirs, or target_configdirs; see the serialization section below.
1884
1885 # Dependency sorting is only needed when *configuration* must be done in
1886 # a particular order.  In all cases a dependency should be specified in
1887 # the Makefile, whether or not it's implicitly specified here.
1888
1889 # Double entries in build_configdirs, configdirs, or target_configdirs may
1890 # cause circular dependencies and break everything horribly.
1891
1892 # these library is used by various programs built for the build
1893 # environment
1894 #
1895 build_libs="build-libiberty"
1896
1897 # these tools are built for the build environment
1898 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1899
1900 # these libraries are used by various programs built for the host environment
1901 #
1902 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1903
1904 # these tools are built for the host environment
1905 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1906 # know that we are building the simulator.
1907 # binutils, gas and ld appear in that order because it makes sense to run
1908 # "make check" in that particular order.
1909 # If --enable-gold is used, "gold" will replace "ld".
1910 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"
1911
1912 # libgcj represents the runtime libraries only used by gcj.
1913 libgcj="target-libffi \
1914         target-zlib \
1915         target-qthreads \
1916         target-libjava"
1917
1918 # these libraries are built for the target environment, and are built after
1919 # the host libraries and the host tools (which may be a cross compiler)
1920 #
1921 target_libraries="target-libgcc \
1922                 target-libiberty \
1923                 target-libgloss \
1924                 target-newlib \
1925                 target-libgomp \
1926                 target-libstdc++-v3 \
1927                 target-libmudflap \
1928                 target-libssp \
1929                 target-libgfortran \
1930                 target-boehm-gc \
1931                 ${libgcj} \
1932                 target-libobjc \
1933                 target-libada"
1934
1935 # these tools are built using the target libraries, and are intended to
1936 # run only in the target environment
1937 #
1938 # note: any program that *uses* libraries that are in the "target_libraries"
1939 # list belongs in this list.  those programs are also very likely
1940 # candidates for the "native_only" list which follows
1941 #
1942 target_tools="target-examples target-groff target-gperf target-rda"
1943
1944 ################################################################################
1945
1946 ## All tools belong in one of the four categories, and are assigned above
1947 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1948 ## is important because configure will choke if they ever get through.
1949 ## ${configdirs} is directories we build using the host tools.
1950 ## ${target_configdirs} is directories we build using the target tools.
1951 configdirs=`echo ${host_libs} ${host_tools}`
1952 target_configdirs=`echo ${target_libraries} ${target_tools}`
1953 build_configdirs=`echo ${build_libs} ${build_tools}`
1954
1955
1956
1957 ################################################################################
1958
1959 srcname="gnu development package"
1960
1961 # This gets set non-empty for some net releases of packages.
1962 appdirs=""
1963
1964 # Define is_cross_compiler to save on calls to 'test'.
1965 is_cross_compiler=
1966 if test x"${host}" = x"${target}" ; then
1967   is_cross_compiler=no
1968 else
1969   is_cross_compiler=yes
1970 fi
1971
1972 # Find the build and target subdir names.
1973
1974 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1975 # have matching libraries, they should use host libraries: Makefile.tpl
1976 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1977 # However, they still use the build modules, because the corresponding
1978 # host modules (e.g. bison) are only built for the host when bootstrap
1979 # finishes. So:
1980 # - build_subdir is where we find build modules, and never changes.
1981 # - build_libsubdir is where we find build libraries, and can be overridden.
1982
1983 # Prefix 'build-' so this never conflicts with target_subdir.
1984 build_subdir="build-${build_noncanonical}"
1985
1986 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1987 if test "${with_build_libsubdir+set}" = set; then
1988   withval="$with_build_libsubdir"
1989   build_libsubdir="$withval"
1990 else
1991   build_libsubdir="$build_subdir"
1992 fi;
1993 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1994 if ( test $srcdir = . && test -d gcc ) \
1995    || test -d $srcdir/../host-${host_noncanonical}; then
1996   host_subdir="host-${host_noncanonical}"
1997 else
1998   host_subdir=.
1999 fi
2000 # No prefix.
2001 target_subdir=${target_noncanonical}
2002
2003
2004 # Skipdirs are removed silently.
2005 skipdirs=
2006 # Noconfigdirs are removed loudly.
2007 noconfigdirs=""
2008
2009 use_gnu_ld=
2010 # Make sure we don't let GNU ld be added if we didn't want it.
2011 if test x$with_gnu_ld = xno ; then
2012   use_gnu_ld=no
2013   noconfigdirs="$noconfigdirs ld gold"
2014 fi
2015
2016 use_gnu_as=
2017 # Make sure we don't let GNU as be added if we didn't want it.
2018 if test x$with_gnu_as = xno ; then
2019   use_gnu_as=no
2020   noconfigdirs="$noconfigdirs gas"
2021 fi
2022
2023 # some tools are so dependent upon X11 that if we're not building with X,
2024 # it's not even worth trying to configure, much less build, that tool.
2025
2026 case ${with_x} in
2027   yes | "") ;; # the default value for this tree is that X11 is available
2028   no)
2029     skipdirs="${skipdirs} tk itcl libgui"
2030     # We won't be able to build gdbtk without X.
2031     enable_gdbtk=no
2032     ;;
2033   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2034 esac
2035
2036 # Some tools are only suitable for building in a "native" situation.
2037 # Remove these if host!=target.
2038 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"
2039
2040 # Similarly, some are only suitable for cross toolchains.
2041 # Remove these if host=target.
2042 cross_only="target-libgloss target-newlib target-opcodes"
2043
2044 case $is_cross_compiler in
2045   no) skipdirs="${skipdirs} ${cross_only}" ;;
2046   yes) skipdirs="${skipdirs} ${native_only}" ;;
2047 esac
2048
2049 # If both --with-headers and --with-libs are specified, default to
2050 # --without-newlib.
2051 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2052    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2053   if test x"${with_newlib}" = x ; then
2054     with_newlib=no
2055   fi
2056 fi
2057
2058 # Recognize --with-newlib/--without-newlib.
2059 case ${with_newlib} in
2060   no) skipdirs="${skipdirs} target-newlib" ;;
2061   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2062 esac
2063
2064 # Handle --enable-gold.
2065
2066 # Check whether --enable-gold or --disable-gold was given.
2067 if test "${enable_gold+set}" = set; then
2068   enableval="$enable_gold"
2069   ENABLE_GOLD=$enableval
2070 else
2071   ENABLE_GOLD=no
2072 fi;
2073 if test "${ENABLE_GOLD}" = "yes"; then
2074   # Check for ELF target.
2075   is_elf=no
2076   case "${target}" in
2077     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2078     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2079     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2080       case "${target}" in
2081         *-*-linux*aout* | *-*-linux*oldld*)
2082           ;;
2083         *)
2084           is_elf=yes
2085           ;;
2086       esac
2087   esac
2088
2089   if test "$is_elf" = "yes"; then
2090     # Check for target supported by gold.
2091     case "${target}" in
2092       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2093         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2094         ;;
2095     esac
2096   fi
2097 fi
2098
2099 # Configure extra directories which are host specific
2100
2101 case "${host}" in
2102   *-cygwin*)
2103     configdirs="$configdirs libtermcap" ;;
2104 esac
2105
2106 # A target can indicate whether a language isn't supported for some reason.
2107 # Only spaces may be used in this macro; not newlines or tabs.
2108 unsupported_languages=
2109
2110 # Remove more programs from consideration, based on the host or
2111 # target this usually means that a port of the program doesn't
2112 # exist yet.
2113
2114 case "${host}" in
2115   hppa*64*-*-*)
2116     noconfigdirs="$noconfigdirs byacc"
2117     ;;
2118   i[3456789]86-*-vsta)
2119     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2120     ;;
2121   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2122     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2123     ;;
2124   x86_64-*-mingw*)
2125     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2126     ;;
2127   i[3456789]86-*-mingw32*)
2128     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2129     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2130     ;;
2131   i[3456789]86-*-beos*)
2132     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2133     ;;
2134   *-*-cygwin*)
2135     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2136     ;;
2137   *-*-netbsd*)
2138     noconfigdirs="$noconfigdirs rcs"
2139     ;;
2140   ppc*-*-pe)
2141     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2142     ;;
2143   powerpc-*-beos*)
2144     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2145     ;;
2146 esac
2147
2148
2149 # Check whether --enable-libada or --disable-libada was given.
2150 if test "${enable_libada+set}" = set; then
2151   enableval="$enable_libada"
2152   ENABLE_LIBADA=$enableval
2153 else
2154   ENABLE_LIBADA=yes
2155 fi;
2156 if test "${ENABLE_LIBADA}" != "yes" ; then
2157   noconfigdirs="$noconfigdirs gnattools"
2158 fi
2159
2160 # Check whether --enable-libssp or --disable-libssp was given.
2161 if test "${enable_libssp+set}" = set; then
2162   enableval="$enable_libssp"
2163   ENABLE_LIBSSP=$enableval
2164 else
2165   ENABLE_LIBSSP=yes
2166 fi;
2167
2168 # Save it here so that, even in case of --enable-libgcj, if the Java
2169 # front-end isn't enabled, we still get libgcj disabled.
2170 libgcj_saved=$libgcj
2171 case $enable_libgcj in
2172 yes)
2173   # If we reset it here, it won't get added to noconfigdirs in the
2174   # target-specific build rules, so it will be forcibly enabled
2175   # (unless the Java language itself isn't enabled).
2176   libgcj=
2177   ;;
2178 no)
2179   # Make sure we get it printed in the list of not supported target libs.
2180   noconfigdirs="$noconfigdirs ${libgcj}"
2181   ;;
2182 esac
2183
2184
2185 # Disable libmudflap on some systems.
2186 if test x$enable_libmudflap = x ; then
2187     case "${target}" in
2188     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2189         # Enable libmudflap by default in GNU and friends.
2190         ;;
2191     *-*-freebsd*)
2192         # Enable libmudflap by default in FreeBSD.
2193         ;;
2194     *)
2195         # Disable it by default everywhere else.
2196         noconfigdirs="$noconfigdirs target-libmudflap"
2197         ;;
2198     esac
2199 fi
2200
2201 # Disable libgomp on non POSIX hosted systems.
2202 if test x$enable_libgomp = x ; then
2203     # Enable libgomp by default on hosted POSIX systems.
2204     case "${target}" in
2205     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2206         ;;
2207     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2208         ;;
2209     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2210         ;;
2211     *-*-darwin* | *-*-aix*)
2212         ;;
2213     *)
2214         noconfigdirs="$noconfigdirs target-libgomp"
2215         ;;
2216     esac
2217 fi
2218
2219 # Default libgloss CPU subdirectory.
2220 libgloss_dir="$target_cpu"
2221
2222 case "${target}" in
2223   *-*-chorusos)
2224     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2225     ;;
2226   powerpc-*-darwin*)
2227     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2228     noconfigdirs="$noconfigdirs sim target-rda"
2229     ;;
2230   i[3456789]86-*-darwin*)
2231     noconfigdirs="$noconfigdirs ld gprof"
2232     noconfigdirs="$noconfigdirs sim target-rda"
2233     ;;
2234   x86_64-*-darwin[912]*)
2235     noconfigdirs="$noconfigdirs ld gas gprof"
2236     noconfigdirs="$noconfigdirs sim target-rda"
2237     ;;
2238   *-*-darwin*)
2239     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2240     noconfigdirs="$noconfigdirs sim target-rda"
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     ;;
2243   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2244     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2245     ;;
2246   *-*-freebsd*)
2247     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2248     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2249         && test -f /usr/local/include/gmp.h; then
2250       with_gmp=/usr/local
2251     fi
2252
2253     # Skip some stuff that's unsupported on some FreeBSD configurations.
2254     case "${target}" in
2255       i*86-*-*) ;;
2256       alpha*-*-*) ;;
2257       *)
2258         noconfigdirs="$noconfigdirs ${libgcj}"
2259         ;;
2260     esac
2261     ;;
2262   *-*-kaos*)
2263     # Remove unsupported stuff on all kaOS configurations.
2264     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2265     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2266     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2267     noconfigdirs="$noconfigdirs target-libgloss"
2268     ;;
2269   *-*-netbsd*)
2270     # Skip some stuff on all NetBSD configurations.
2271     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2272
2273     # Skip some stuff that's unsupported on some NetBSD configurations.
2274     case "${target}" in
2275       i*86-*-netbsdelf*) ;;
2276       arm*-*-netbsdelf*) ;;
2277       *)
2278         noconfigdirs="$noconfigdirs ${libgcj}"
2279         ;;
2280     esac
2281     ;;
2282   *-*-netware*)
2283     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2284     ;;
2285   *-*-rtems*)
2286     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2287     ;;
2288     # The tpf target doesn't support gdb yet.
2289   *-*-tpf*)
2290     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2291     ;;
2292   *-*-uclinux*)
2293     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2294     ;;
2295   *-*-vxworks*)
2296     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2297     ;;
2298   alpha*-dec-osf*)
2299     # ld works, but does not support shared libraries.
2300     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2301     # gas doesn't generate exception information.
2302     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2303     ;;
2304   alpha*-*-*vms*)
2305     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2306     ;;
2307   alpha*-*-linux*)
2308     # newlib is not 64 bit ready
2309     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2310     ;;
2311   alpha*-*-*)
2312     # newlib is not 64 bit ready
2313     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2314     ;;
2315   am33_2.0-*-linux*)
2316     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2317     ;;
2318   sh-*-linux*)
2319     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2320     ;;
2321   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2322     noconfigdirs="$noconfigdirs ${libgcj}"
2323     noconfigdirs="$noconfigdirs target-examples"
2324     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2325     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2326     noconfigdirs="$noconfigdirs expect dejagnu"
2327     # the C++ libraries don't build on top of CE's C libraries
2328     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2329     noconfigdirs="$noconfigdirs target-newlib"
2330     case "${host}" in
2331       *-*-cygwin*) ;; # keep gdb and readline
2332       *) noconfigdirs="$noconfigdirs gdb readline"
2333          ;;
2334     esac
2335     libgloss_dir=wince
2336     ;;
2337   arc-*-*)
2338     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2339     ;;
2340   arm-semi-aof )
2341     ;;
2342   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2343     noconfigdirs="$noconfigdirs ${libgcj}"
2344     libgloss_dir=arm
2345     ;;
2346   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2347     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2348     libgloss_dir=arm
2349     ;;
2350   arm*-*-linux-gnueabi)
2351     noconfigdirs="$noconfigdirs target-qthreads"
2352     case ${with_newlib} in
2353       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2354     esac
2355     libgloss_dir=arm
2356     ;;
2357   arm*-*-symbianelf*)
2358     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2359     libgloss_dir=arm
2360     ;;
2361   arm-*-pe*)
2362     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2363     ;;
2364   thumb-*-coff)
2365     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2366     ;;
2367   thumb-*-elf)
2368     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2369     ;;
2370   thumb-*-pe)
2371     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2372     ;;
2373   arm-*-riscix*)
2374     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2375     ;;
2376   avr-*-*)
2377     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2378     ;;
2379   bfin-*-*)
2380     noconfigdirs="$noconfigdirs gdb"
2381     if test x${is_cross_compiler} != xno ; then
2382       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2383     fi
2384     ;;
2385   c4x-*-* | tic4x-*-*)
2386     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2387     ;;
2388   c54x*-*-* | tic54x-*-*)
2389     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2390     ;;
2391   cr16-*-*)
2392     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2393     ;;
2394   cris-*-* | crisv32-*-*)
2395     unsupported_languages="$unsupported_languages java"
2396     case "${target}" in
2397       *-*-aout)
2398         unsupported_languages="$unsupported_languages fortran"
2399         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2400       *-*-elf)
2401         noconfigdirs="$noconfigdirs target-boehm-gc";;
2402       *-*-linux*)
2403         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2404       *)
2405         unsupported_languages="$unsupported_languages fortran"
2406         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2407     esac
2408     libgloss_dir=cris
2409     ;;
2410   crx-*-*)
2411     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2412     ;;
2413   d10v-*-*)
2414     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2415     ;;
2416   d30v-*-*)
2417     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2418     ;;
2419   ep9312-*-elf | ep9312-*-coff)
2420     libgloss_dir=arm
2421     ;;
2422   fr30-*-elf*)
2423     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2424     ;;
2425   frv-*-*)
2426     noconfigdirs="$noconfigdirs ${libgcj}"
2427     ;;
2428   moxie-*-*)
2429     noconfigdirs="$noconfigdirs ${libgcj}"
2430     noconfigdirs="$noconfigdirs gprof"
2431     ;;
2432   h8300*-*-*)
2433     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2434     ;;
2435   h8500-*-*)
2436     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2437     ;;
2438   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2439     ;;
2440   hppa*64*-*-linux* | parisc*64*-*-linux*)
2441     # In this case, it's because the hppa64-linux target is for
2442     # the kernel only at this point and has no libc, and thus no
2443     # headers, crt*.o, etc., all of which are needed by these.
2444     noconfigdirs="$noconfigdirs target-zlib"
2445     ;;
2446   parisc*-*-linux* | hppa*-*-linux*)
2447     ;;
2448   hppa*-*-*elf* | \
2449   hppa*-*-lites* | \
2450   hppa*-*-openbsd* | \
2451   hppa*64*-*-*)
2452     noconfigdirs="$noconfigdirs ${libgcj}"
2453     ;;
2454   hppa*-hp-hpux11*)
2455     noconfigdirs="$noconfigdirs ld shellutils"
2456     ;;
2457   hppa*-*-pro*)
2458     libgloss_dir=pa
2459     ;;
2460   hppa*-*-*)
2461     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2462     # build on HP-UX 10.20.
2463     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2464     ;;
2465   i960-*-*)
2466     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2467     ;;
2468   ia64*-*-elf*)
2469     # No gdb support yet.
2470     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2471     ;;
2472   ia64*-**-hpux*)
2473     # No gdb or ld support yet.
2474     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2475     ;;
2476   ia64*-*-*vms*)
2477     # No gdb or ld support yet.
2478     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2479     ;;
2480   i370-*-opened*)
2481     ;;
2482   i[3456789]86-*-coff | i[3456789]86-*-elf)
2483     noconfigdirs="$noconfigdirs ${libgcj}"
2484     libgloss_dir=i386
2485     ;;
2486   i[3456789]86-*-linux*)
2487     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2488     # not build java stuff by default.
2489     case "${target}" in
2490       *-*-*libc1*)
2491         noconfigdirs="$noconfigdirs ${libgcj}";;
2492     esac
2493
2494     # This section makes it possible to build newlib natively on linux.
2495     # If we are using a cross compiler then don't configure newlib.
2496     if test x${is_cross_compiler} != xno ; then
2497       noconfigdirs="$noconfigdirs target-newlib"
2498     fi
2499     noconfigdirs="$noconfigdirs target-libgloss"
2500     # If we are not using a cross compiler, do configure newlib.
2501     # Note however, that newlib will only be configured in this situation
2502     # if the --with-newlib option has been given, because otherwise
2503     # 'target-newlib' will appear in skipdirs.
2504     ;;
2505   i[3456789]86-*-mingw32*)
2506     target_configdirs="$target_configdirs target-winsup"
2507     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2508     ;;
2509   x86_64-*-mingw*)
2510     target_configdirs="$target_configdirs target-winsup"
2511     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2512     ;;
2513   *-*-cygwin*)
2514     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2515     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2516     # always build newlib if winsup directory is present.
2517     if test -d "$srcdir/winsup/cygwin"; then
2518       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2519     elif test -d "$srcdir/newlib"; then
2520       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2521     fi
2522     ;;
2523   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2524   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2525     ;;
2526   i[3456789]86-*-pe)
2527     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2528     ;;
2529   i[3456789]86-*-sco3.2v5*)
2530     # The linker does not yet know about weak symbols in COFF,
2531     # and is not configured to handle mixed ELF and COFF.
2532     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2533     ;;
2534   i[3456789]86-*-sco*)
2535     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2536     ;;
2537   i[3456789]86-*-solaris2*)
2538     noconfigdirs="$noconfigdirs target-libgloss"
2539     ;;
2540   i[3456789]86-*-sysv4*)
2541     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2542     ;;
2543   i[3456789]86-*-beos*)
2544     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2545     ;;
2546   i[3456789]86-*-rdos*)
2547     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2548     ;;
2549   m32r-*-*)
2550     noconfigdirs="$noconfigdirs ${libgcj}"
2551     ;;
2552   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2553     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2554     libgloss_dir=m68hc11
2555     ;;
2556   m68k-*-elf*)
2557     noconfigdirs="$noconfigdirs ${libgcj}"
2558     ;;
2559   m68k-*-coff*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     ;;
2562   m68*-*-* | fido-*-*)
2563     libgloss_dir=m68k
2564     ;;
2565   mcore-*-pe*)
2566   # The EPOC C++ environment does not support exceptions or rtti,
2567   # and so building libstdc++-v3 tends not to always work.
2568     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2569     ;;
2570   mmix-*-*)
2571     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2572     unsupported_languages="$unsupported_languages fortran java"
2573     ;;
2574   mn10200-*-*)
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     ;;
2577   mn10300-*-*)
2578     noconfigdirs="$noconfigdirs ${libgcj}"
2579     ;;
2580   mt-*-*)
2581     noconfigdirs="$noconfigdirs sim"
2582     ;;
2583   powerpc-*-aix*)
2584     # copied from rs6000-*-* entry
2585     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2586     ;;
2587   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2588     target_configdirs="$target_configdirs target-winsup"
2589     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2590     # always build newlib.
2591     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2592     ;;
2593     # This is temporary until we can link against shared libraries
2594   powerpcle-*-solaris*)
2595     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2596     libgloss_dir=rs6000
2597     ;;
2598   powerpc-*-beos*)
2599     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2600     ;;
2601   powerpc-*-eabi)
2602     noconfigdirs="$noconfigdirs ${libgcj}"
2603     libgloss_dir=rs6000
2604     ;;
2605   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2606     libgloss_dir=rs6000
2607     ;;
2608   rs6000-*-lynxos*)
2609     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2610     ;;
2611   rs6000-*-aix*)
2612     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2613     ;;
2614   rs6000-*-*)
2615     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2616     ;;
2617   m68k-apollo-*)
2618     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2619     ;;
2620   microblaze*)
2621     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2622     ;;
2623   mips*-sde-elf*)
2624     skipdirs="$skipdirs target-libiberty"
2625     noconfigdirs="$noconfigdirs ${libgcj}"
2626     if test x$with_newlib = xyes; then
2627       noconfigdirs="$noconfigdirs gprof"
2628     fi
2629     libgloss_dir=mips
2630     ;;
2631   mips*-*-irix5*)
2632     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2633     ;;
2634   mips*-*-irix6*)
2635     # Linking libjava exceeds command-line length limits on at least
2636     # IRIX 6.2, but not on IRIX 6.5.
2637     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2638     # <oldham@codesourcery.com>
2639     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2640     ;;
2641   mips*-*-bsd*)
2642     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2643     ;;
2644   mips*-*-linux*)
2645     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2646     ;;
2647   mips*-*-*)
2648     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2649     libgloss_dir=mips
2650     ;;
2651   romp-*-*)
2652     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2653     ;;
2654   sh-*-* | sh64-*-*)
2655     case "${host}" in
2656       i[3456789]86-*-vsta) ;; # don't add gprof back in
2657       i[3456789]86-*-go32*) ;; # don't add gprof back in
2658       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2659       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2660     esac
2661     case "${target}" in
2662       sh*-*-elf)
2663          noconfigdirs="$noconfigdirs ${libgcj}" ;;
2664       *)
2665          noconfigdirs="$noconfigdirs target-libgloss ${libgcj}" ;;
2666     esac
2667     ;;
2668   sparclet-*-aout* | sparc86x-*-*)
2669     libgloss_dir=sparc
2670     ;;
2671   sparc-*-elf*)
2672     noconfigdirs="$noconfigdirs ${libgcj}"
2673     ;;
2674   sparc64-*-elf*)
2675     noconfigdirs="$noconfigdirs ${libgcj}"
2676     libgloss_dir=sparc
2677     ;;
2678   sparclite-*-*)
2679     noconfigdirs="$noconfigdirs ${libgcj}"
2680     libgloss_dir=sparc
2681     ;;
2682   sparc-*-sunos4*)
2683     noconfigdirs="$noconfigdirs ${libgcj}"
2684     if test x${is_cross_compiler} != xno ; then
2685            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2686     else
2687            use_gnu_ld=no
2688     fi
2689     ;;
2690   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2691     noconfigdirs="$noconfigdirs ${libgcj}"
2692     ;;
2693   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2694     ;;
2695   v810-*-*)
2696     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2697     ;;
2698   v850-*-*)
2699     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2700     ;;
2701   v850e-*-*)
2702     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2703     ;;
2704   v850ea-*-*)
2705     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2706     ;;
2707   vax-*-vms)
2708     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2709     ;;
2710   vax-*-*)
2711     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2712     ;;
2713   xtensa*-*-*)
2714     noconfigdirs="$noconfigdirs ${libgcj}"
2715     ;;
2716   ip2k-*-*)
2717     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2718     ;;
2719   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2720     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2721     ;;
2722   *-*-lynxos*)
2723     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2724     ;;
2725   *-*-*)
2726     noconfigdirs="$noconfigdirs ${libgcj}"
2727     ;;
2728 esac
2729
2730 # If we aren't building newlib, then don't build libgloss, since libgloss
2731 # depends upon some newlib header files.
2732 case "${noconfigdirs}" in
2733   *target-libgloss*) ;;
2734   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2735 esac
2736
2737 # Work in distributions that contain no compiler tools, like Autoconf.
2738 tentative_cc=""
2739 host_makefile_frag=/dev/null
2740 if test -d ${srcdir}/config ; then
2741 case "${host}" in
2742   m68k-hp-hpux*)
2743     # Avoid "too much defining" errors from HPUX compiler.
2744     tentative_cc="cc -Wp,-H256000"
2745     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2746     # If it's HP/UX ar, this should be harmless.
2747     RANLIB="ar ts"
2748     ;;
2749   m68k-apollo-sysv*)
2750     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2751     ;;
2752   m68k-apollo-bsd*)
2753     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2754     # chokes on bfd, the compiler won't let you assign integers to enums, and
2755     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2756     # the apollo compiler" (the preferred version of GCC could be called cc,
2757     # or whatever), but I'm not sure leaving CC as cc is any better...
2758     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2759     # Used to have BISON=yacc.
2760     tentative_cc=gcc
2761     ;;
2762   m88k-dg-dgux*)
2763     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2764     ;;
2765   m88k-harris-cxux*)
2766     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2767     tentative_cc="cc -Xa"
2768     host_makefile_frag="config/mh-cxux"
2769     ;;
2770   m88k-motorola-sysv*)
2771     ;;
2772   mips*-dec-ultrix*)
2773     tentative_cc="cc -Wf,-XNg1000"
2774     host_makefile_frag="config/mh-decstation"
2775     ;;
2776   mips*-nec-sysv4*)
2777     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2778     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2779     host_makefile_frag="config/mh-necv4"
2780     ;;
2781   mips*-sgi-irix4*)
2782     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2783     # environment.  Also bump switch table size so that cp-parse will
2784     # compile.  Bump string length limit so linker builds.
2785     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2786     ;;
2787   mips*-*-sysv4*)
2788     host_makefile_frag="config/mh-sysv4"
2789     ;;
2790   mips*-*-sysv*)
2791     # This is for a MIPS running RISC/os 4.52C.
2792
2793     # This is needed for GDB, but needs to be in the top-level make because
2794     # if a library is compiled with the bsd headers and gets linked with the
2795     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2796     # a different size).
2797     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2798     # known except to select the sysv environment.  Could we use /proc instead?
2799     # These "sysv environments" and "bsd environments" often end up being a pain.
2800     #
2801     # This is not part of CFLAGS because perhaps not all C compilers have this
2802     # option.
2803     tentative_cc="cc -systype sysv"
2804     ;;
2805   i370-ibm-opened*)
2806     tentative_cc="c89"
2807     ;;
2808   i[3456789]86-*-sysv5*)
2809     host_makefile_frag="config/mh-sysv5"
2810     ;;
2811   i[3456789]86-*-dgux*)
2812     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2813     host_makefile_frag="config/mh-dgux386"
2814     ;;
2815   i[3456789]86-ncr-sysv4.3*)
2816     # The MetaWare compiler will generate a copyright message unless you
2817     # turn it off by adding the -Hnocopyr flag.
2818     tentative_cc="cc -Hnocopyr"
2819     ;;
2820   i[3456789]86-ncr-sysv4*)
2821     # for an NCR 3000 (i486/SVR4) system.
2822     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2823     # This compiler not only emits obnoxious copyright messages every time
2824     # you run it, but it chokes and dies on a whole bunch of GNU source
2825     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2826     tentative_cc="/usr/ccs/ATT/cc"
2827     host_makefile_frag="config/mh-ncr3000"
2828     ;;
2829   i[3456789]86-*-sco3.2v5*)
2830     ;;
2831   i[3456789]86-*-sco*)
2832     # The native C compiler botches some simple uses of const.  Unfortunately,
2833     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2834     tentative_cc="cc -Dconst="
2835     host_makefile_frag="config/mh-sco"
2836     ;;
2837   i[3456789]86-*-udk*)
2838     host_makefile_frag="config/mh-sysv5"
2839     ;;
2840   i[3456789]86-*-solaris2*)
2841     host_makefile_frag="config/mh-sysv4"
2842     ;;
2843   i[3456789]86-*-msdosdjgpp*)
2844     host_makefile_frag="config/mh-djgpp"
2845     ;;
2846   *-cygwin*)
2847
2848 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2849 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2850 echo a >cygwin-cat-check
2851 if test `cat cygwin-cat-check` == a ; then
2852   rm cygwin-cat-check
2853   echo "$as_me:$LINENO: result: yes" >&5
2854 echo "${ECHO_T}yes" >&6
2855 else
2856   rm cygwin-cat-check
2857   echo "$as_me:$LINENO: result: no" >&5
2858 echo "${ECHO_T}no" >&6
2859   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2860   Please either mount the build directory in binary mode or run the following
2861   commands before running any configure script:
2862 set -o igncr
2863 export SHELLOPTS
2864   " >&5
2865 echo "$as_me: error: The cat command does not ignore carriage return characters.
2866   Please either mount the build directory in binary mode or run the following
2867   commands before running any configure script:
2868 set -o igncr
2869 export SHELLOPTS
2870   " >&2;}
2871    { (exit 1); exit 1; }; }
2872 fi
2873
2874     host_makefile_frag="config/mh-cygwin"
2875     ;;
2876   *-mingw*)
2877     host_makefile_frag="config/mh-mingw"
2878     ;;
2879   *-interix*)
2880     host_makefile_frag="config/mh-interix"
2881     ;;
2882   vax-*-ultrix2*)
2883     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2884     tentative_cc=gcc
2885     ;;
2886   *-*-solaris2*)
2887     host_makefile_frag="config/mh-solaris"
2888     ;;
2889   m68k-sun-sunos*)
2890     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2891     # without overflowing the jump tables (-J says to use a 32 bit table)
2892     tentative_cc="cc -J"
2893     ;;
2894   hppa*-hp-hpux10*)
2895     tentative_cc="cc -Wp,-H256000"
2896     host_makefile_frag="config/mh-pa-hpux10"
2897     ;;
2898   hppa*-hp-hpux* | hppa*-*-hiux*)
2899     tentative_cc="cc -Wp,-H256000"
2900     host_makefile_frag="config/mh-pa"
2901     ;;
2902   hppa*-*)
2903     host_makefile_frag="config/mh-pa"
2904     ;;
2905   *-hp-hpux* | *-*-hiux*)
2906     tentative_cc="cc -Wp,-H256000"
2907     ;;
2908   rs6000-*-lynxos*)
2909     # /bin/cc is less than useful for our purposes.  Always use GCC
2910     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2911     host_makefile_frag="config/mh-lynxrs6k"
2912     ;;
2913   powerpc-*-darwin*)
2914     host_makefile_frag="config/mh-ppc-darwin"
2915     ;;
2916   powerpc-*-aix*)
2917     host_makefile_frag="config/mh-ppc-aix"
2918     ;;
2919   rs6000-*-aix*)
2920     host_makefile_frag="config/mh-ppc-aix"
2921     ;;
2922   *-*-lynxos*)
2923     # /bin/cc is less than useful for our purposes.  Always use GCC
2924     tentative_cc="/bin/gcc"
2925     ;;
2926   *-*-sysv4*)
2927     host_makefile_frag="config/mh-sysv4"
2928     ;;
2929   # This is placed last to prevent interfering with the cases above.
2930   i[3456789]86-*-*)
2931     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2932     host_makefile_frag="config/mh-x86omitfp"
2933     ;;
2934 esac
2935 fi
2936
2937 # If we aren't going to be using gcc, see if we can extract a definition
2938 # of CC from the fragment.
2939 # Actually, use the 'pre-extracted' version above.
2940 if test -z "${CC}" && test "${build}" = "${host}" ; then
2941   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2942   found=
2943   for dir in $PATH; do
2944     test -z "$dir" && dir=.
2945     if test -f $dir/gcc; then
2946       found=yes
2947       break
2948     fi
2949   done
2950   IFS="$save_ifs"
2951   if test -z "${found}" && test -n "${tentative_cc}" ; then
2952     CC=$tentative_cc
2953   fi
2954 fi
2955
2956 if test "${build}" != "${host}" ; then
2957   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2958   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2959   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2960   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2961   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2962   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2963   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2964   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2965   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2966   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2967   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2968   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2969 else
2970   AR_FOR_BUILD="\$(AR)"
2971   AS_FOR_BUILD="\$(AS)"
2972   CC_FOR_BUILD="\$(CC)"
2973   CXX_FOR_BUILD="\$(CXX)"
2974   GCJ_FOR_BUILD="\$(GCJ)"
2975   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2976   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2977   LD_FOR_BUILD="\$(LD)"
2978   NM_FOR_BUILD="\$(NM)"
2979   RANLIB_FOR_BUILD="\$(RANLIB)"
2980   WINDRES_FOR_BUILD="\$(WINDRES)"
2981   WINDMC_FOR_BUILD="\$(WINDMC)"
2982 fi
2983
2984 ac_ext=c
2985 ac_cpp='$CPP $CPPFLAGS'
2986 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2987 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2988 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2989 if test -n "$ac_tool_prefix"; then
2990   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2991 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2992 echo "$as_me:$LINENO: checking for $ac_word" >&5
2993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2994 if test "${ac_cv_prog_CC+set}" = set; then
2995   echo $ECHO_N "(cached) $ECHO_C" >&6
2996 else
2997   if test -n "$CC"; then
2998   ac_cv_prog_CC="$CC" # Let the user override the test.
2999 else
3000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3001 for as_dir in $PATH
3002 do
3003   IFS=$as_save_IFS
3004   test -z "$as_dir" && as_dir=.
3005   for ac_exec_ext in '' $ac_executable_extensions; do
3006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3007     ac_cv_prog_CC="${ac_tool_prefix}gcc"
3008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3009     break 2
3010   fi
3011 done
3012 done
3013
3014 fi
3015 fi
3016 CC=$ac_cv_prog_CC
3017 if test -n "$CC"; then
3018   echo "$as_me:$LINENO: result: $CC" >&5
3019 echo "${ECHO_T}$CC" >&6
3020 else
3021   echo "$as_me:$LINENO: result: no" >&5
3022 echo "${ECHO_T}no" >&6
3023 fi
3024
3025 fi
3026 if test -z "$ac_cv_prog_CC"; then
3027   ac_ct_CC=$CC
3028   # Extract the first word of "gcc", so it can be a program name with args.
3029 set dummy gcc; ac_word=$2
3030 echo "$as_me:$LINENO: checking for $ac_word" >&5
3031 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3032 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3033   echo $ECHO_N "(cached) $ECHO_C" >&6
3034 else
3035   if test -n "$ac_ct_CC"; then
3036   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3037 else
3038 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3039 for as_dir in $PATH
3040 do
3041   IFS=$as_save_IFS
3042   test -z "$as_dir" && as_dir=.
3043   for ac_exec_ext in '' $ac_executable_extensions; do
3044   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3045     ac_cv_prog_ac_ct_CC="gcc"
3046     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3047     break 2
3048   fi
3049 done
3050 done
3051
3052 fi
3053 fi
3054 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3055 if test -n "$ac_ct_CC"; then
3056   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3057 echo "${ECHO_T}$ac_ct_CC" >&6
3058 else
3059   echo "$as_me:$LINENO: result: no" >&5
3060 echo "${ECHO_T}no" >&6
3061 fi
3062
3063   CC=$ac_ct_CC
3064 else
3065   CC="$ac_cv_prog_CC"
3066 fi
3067
3068 if test -z "$CC"; then
3069   if test -n "$ac_tool_prefix"; then
3070   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3071 set dummy ${ac_tool_prefix}cc; ac_word=$2
3072 echo "$as_me:$LINENO: checking for $ac_word" >&5
3073 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3074 if test "${ac_cv_prog_CC+set}" = set; then
3075   echo $ECHO_N "(cached) $ECHO_C" >&6
3076 else
3077   if test -n "$CC"; then
3078   ac_cv_prog_CC="$CC" # Let the user override the test.
3079 else
3080 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3081 for as_dir in $PATH
3082 do
3083   IFS=$as_save_IFS
3084   test -z "$as_dir" && as_dir=.
3085   for ac_exec_ext in '' $ac_executable_extensions; do
3086   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3087     ac_cv_prog_CC="${ac_tool_prefix}cc"
3088     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3089     break 2
3090   fi
3091 done
3092 done
3093
3094 fi
3095 fi
3096 CC=$ac_cv_prog_CC
3097 if test -n "$CC"; then
3098   echo "$as_me:$LINENO: result: $CC" >&5
3099 echo "${ECHO_T}$CC" >&6
3100 else
3101   echo "$as_me:$LINENO: result: no" >&5
3102 echo "${ECHO_T}no" >&6
3103 fi
3104
3105 fi
3106 if test -z "$ac_cv_prog_CC"; then
3107   ac_ct_CC=$CC
3108   # Extract the first word of "cc", so it can be a program name with args.
3109 set dummy cc; ac_word=$2
3110 echo "$as_me:$LINENO: checking for $ac_word" >&5
3111 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3112 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3113   echo $ECHO_N "(cached) $ECHO_C" >&6
3114 else
3115   if test -n "$ac_ct_CC"; then
3116   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3117 else
3118 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3119 for as_dir in $PATH
3120 do
3121   IFS=$as_save_IFS
3122   test -z "$as_dir" && as_dir=.
3123   for ac_exec_ext in '' $ac_executable_extensions; do
3124   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3125     ac_cv_prog_ac_ct_CC="cc"
3126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3127     break 2
3128   fi
3129 done
3130 done
3131
3132 fi
3133 fi
3134 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3135 if test -n "$ac_ct_CC"; then
3136   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3137 echo "${ECHO_T}$ac_ct_CC" >&6
3138 else
3139   echo "$as_me:$LINENO: result: no" >&5
3140 echo "${ECHO_T}no" >&6
3141 fi
3142
3143   CC=$ac_ct_CC
3144 else
3145   CC="$ac_cv_prog_CC"
3146 fi
3147
3148 fi
3149 if test -z "$CC"; then
3150   # Extract the first word of "cc", so it can be a program name with args.
3151 set dummy cc; ac_word=$2
3152 echo "$as_me:$LINENO: checking for $ac_word" >&5
3153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3154 if test "${ac_cv_prog_CC+set}" = set; then
3155   echo $ECHO_N "(cached) $ECHO_C" >&6
3156 else
3157   if test -n "$CC"; then
3158   ac_cv_prog_CC="$CC" # Let the user override the test.
3159 else
3160   ac_prog_rejected=no
3161 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3162 for as_dir in $PATH
3163 do
3164   IFS=$as_save_IFS
3165   test -z "$as_dir" && as_dir=.
3166   for ac_exec_ext in '' $ac_executable_extensions; do
3167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3168     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3169        ac_prog_rejected=yes
3170        continue
3171      fi
3172     ac_cv_prog_CC="cc"
3173     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3174     break 2
3175   fi
3176 done
3177 done
3178
3179 if test $ac_prog_rejected = yes; then
3180   # We found a bogon in the path, so make sure we never use it.
3181   set dummy $ac_cv_prog_CC
3182   shift
3183   if test $# != 0; then
3184     # We chose a different compiler from the bogus one.
3185     # However, it has the same basename, so the bogon will be chosen
3186     # first if we set CC to just the basename; use the full file name.
3187     shift
3188     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3189   fi
3190 fi
3191 fi
3192 fi
3193 CC=$ac_cv_prog_CC
3194 if test -n "$CC"; then
3195   echo "$as_me:$LINENO: result: $CC" >&5
3196 echo "${ECHO_T}$CC" >&6
3197 else
3198   echo "$as_me:$LINENO: result: no" >&5
3199 echo "${ECHO_T}no" >&6
3200 fi
3201
3202 fi
3203 if test -z "$CC"; then
3204   if test -n "$ac_tool_prefix"; then
3205   for ac_prog in cl
3206   do
3207     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3208 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3209 echo "$as_me:$LINENO: checking for $ac_word" >&5
3210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3211 if test "${ac_cv_prog_CC+set}" = set; then
3212   echo $ECHO_N "(cached) $ECHO_C" >&6
3213 else
3214   if test -n "$CC"; then
3215   ac_cv_prog_CC="$CC" # Let the user override the test.
3216 else
3217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3218 for as_dir in $PATH
3219 do
3220   IFS=$as_save_IFS
3221   test -z "$as_dir" && as_dir=.
3222   for ac_exec_ext in '' $ac_executable_extensions; do
3223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3224     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3226     break 2
3227   fi
3228 done
3229 done
3230
3231 fi
3232 fi
3233 CC=$ac_cv_prog_CC
3234 if test -n "$CC"; then
3235   echo "$as_me:$LINENO: result: $CC" >&5
3236 echo "${ECHO_T}$CC" >&6
3237 else
3238   echo "$as_me:$LINENO: result: no" >&5
3239 echo "${ECHO_T}no" >&6
3240 fi
3241
3242     test -n "$CC" && break
3243   done
3244 fi
3245 if test -z "$CC"; then
3246   ac_ct_CC=$CC
3247   for ac_prog in cl
3248 do
3249   # Extract the first word of "$ac_prog", so it can be a program name with args.
3250 set dummy $ac_prog; ac_word=$2
3251 echo "$as_me:$LINENO: checking for $ac_word" >&5
3252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3253 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3254   echo $ECHO_N "(cached) $ECHO_C" >&6
3255 else
3256   if test -n "$ac_ct_CC"; then
3257   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3258 else
3259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3260 for as_dir in $PATH
3261 do
3262   IFS=$as_save_IFS
3263   test -z "$as_dir" && as_dir=.
3264   for ac_exec_ext in '' $ac_executable_extensions; do
3265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3266     ac_cv_prog_ac_ct_CC="$ac_prog"
3267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3268     break 2
3269   fi
3270 done
3271 done
3272
3273 fi
3274 fi
3275 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3276 if test -n "$ac_ct_CC"; then
3277   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3278 echo "${ECHO_T}$ac_ct_CC" >&6
3279 else
3280   echo "$as_me:$LINENO: result: no" >&5
3281 echo "${ECHO_T}no" >&6
3282 fi
3283
3284   test -n "$ac_ct_CC" && break
3285 done
3286
3287   CC=$ac_ct_CC
3288 fi
3289
3290 fi
3291
3292
3293 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3294 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3295 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3296 See \`config.log' for more details." >&5
3297 echo "$as_me: error: no acceptable C compiler found in \$PATH
3298 See \`config.log' for more details." >&2;}
3299    { (exit 1); exit 1; }; }; }
3300
3301 # Provide some information about the compiler.
3302 echo "$as_me:$LINENO:" \
3303      "checking for C compiler version" >&5
3304 ac_compiler=`set X $ac_compile; echo $2`
3305 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3306   (eval $ac_compiler --version </dev/null >&5) 2>&5
3307   ac_status=$?
3308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3309   (exit $ac_status); }
3310 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3311   (eval $ac_compiler -v </dev/null >&5) 2>&5
3312   ac_status=$?
3313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3314   (exit $ac_status); }
3315 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3316   (eval $ac_compiler -V </dev/null >&5) 2>&5
3317   ac_status=$?
3318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3319   (exit $ac_status); }
3320
3321 cat >conftest.$ac_ext <<_ACEOF
3322 /* confdefs.h.  */
3323 _ACEOF
3324 cat confdefs.h >>conftest.$ac_ext
3325 cat >>conftest.$ac_ext <<_ACEOF
3326 /* end confdefs.h.  */
3327
3328 int
3329 main ()
3330 {
3331
3332   ;
3333   return 0;
3334 }
3335 _ACEOF
3336 ac_clean_files_save=$ac_clean_files
3337 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3338 # Try to create an executable without -o first, disregard a.out.
3339 # It will help us diagnose broken compilers, and finding out an intuition
3340 # of exeext.
3341 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3342 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3343 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3344 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3345   (eval $ac_link_default) 2>&5
3346   ac_status=$?
3347   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3348   (exit $ac_status); }; then
3349   # Find the output, starting from the most likely.  This scheme is
3350 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3351 # resort.
3352
3353 # Be careful to initialize this variable, since it used to be cached.
3354 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3355 ac_cv_exeext=
3356 # b.out is created by i960 compilers.
3357 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3358 do
3359   test -f "$ac_file" || continue
3360   case $ac_file in
3361     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3362         ;;
3363     conftest.$ac_ext )
3364         # This is the source file.
3365         ;;
3366     [ab].out )
3367         # We found the default executable, but exeext='' is most
3368         # certainly right.
3369         break;;
3370     *.* )
3371         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3372         # FIXME: I believe we export ac_cv_exeext for Libtool,
3373         # but it would be cool to find out if it's true.  Does anybody
3374         # maintain Libtool? --akim.
3375         export ac_cv_exeext
3376         break;;
3377     * )
3378         break;;
3379   esac
3380 done
3381 else
3382   echo "$as_me: failed program was:" >&5
3383 sed 's/^/| /' conftest.$ac_ext >&5
3384
3385 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3386 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3387 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3388 See \`config.log' for more details." >&5
3389 echo "$as_me: error: C compiler cannot create executables
3390 See \`config.log' for more details." >&2;}
3391    { (exit 77); exit 77; }; }; }
3392 fi
3393
3394 ac_exeext=$ac_cv_exeext
3395 echo "$as_me:$LINENO: result: $ac_file" >&5
3396 echo "${ECHO_T}$ac_file" >&6
3397
3398 # Check the compiler produces executables we can run.  If not, either
3399 # the compiler is broken, or we cross compile.
3400 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3401 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3402 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3403 # If not cross compiling, check that we can run a simple program.
3404 if test "$cross_compiling" != yes; then
3405   if { ac_try='./$ac_file'
3406   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3407   (eval $ac_try) 2>&5
3408   ac_status=$?
3409   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3410   (exit $ac_status); }; }; then
3411     cross_compiling=no
3412   else
3413     if test "$cross_compiling" = maybe; then
3414         cross_compiling=yes
3415     else
3416         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3417 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3418 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3419 If you meant to cross compile, use \`--host'.
3420 See \`config.log' for more details." >&5
3421 echo "$as_me: error: cannot run C compiled programs.
3422 If you meant to cross compile, use \`--host'.
3423 See \`config.log' for more details." >&2;}
3424    { (exit 1); exit 1; }; }; }
3425     fi
3426   fi
3427 fi
3428 echo "$as_me:$LINENO: result: yes" >&5
3429 echo "${ECHO_T}yes" >&6
3430
3431 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3432 ac_clean_files=$ac_clean_files_save
3433 # Check the compiler produces executables we can run.  If not, either
3434 # the compiler is broken, or we cross compile.
3435 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3436 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3437 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3438 echo "${ECHO_T}$cross_compiling" >&6
3439
3440 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3441 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3442 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3443   (eval $ac_link) 2>&5
3444   ac_status=$?
3445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3446   (exit $ac_status); }; then
3447   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3448 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3449 # work properly (i.e., refer to `conftest.exe'), while it won't with
3450 # `rm'.
3451 for ac_file in conftest.exe conftest conftest.*; do
3452   test -f "$ac_file" || continue
3453   case $ac_file in
3454     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3455     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3456           export ac_cv_exeext
3457           break;;
3458     * ) break;;
3459   esac
3460 done
3461 else
3462   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3463 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3464 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3465 See \`config.log' for more details." >&5
3466 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3467 See \`config.log' for more details." >&2;}
3468    { (exit 1); exit 1; }; }; }
3469 fi
3470
3471 rm -f conftest$ac_cv_exeext
3472 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3473 echo "${ECHO_T}$ac_cv_exeext" >&6
3474
3475 rm -f conftest.$ac_ext
3476 EXEEXT=$ac_cv_exeext
3477 ac_exeext=$EXEEXT
3478 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3479 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3480 if test "${ac_cv_objext+set}" = set; then
3481   echo $ECHO_N "(cached) $ECHO_C" >&6
3482 else
3483   cat >conftest.$ac_ext <<_ACEOF
3484 /* confdefs.h.  */
3485 _ACEOF
3486 cat confdefs.h >>conftest.$ac_ext
3487 cat >>conftest.$ac_ext <<_ACEOF
3488 /* end confdefs.h.  */
3489
3490 int
3491 main ()
3492 {
3493
3494   ;
3495   return 0;
3496 }
3497 _ACEOF
3498 rm -f conftest.o conftest.obj
3499 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3500   (eval $ac_compile) 2>&5
3501   ac_status=$?
3502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3503   (exit $ac_status); }; then
3504   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3505   case $ac_file in
3506     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3507     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3508        break;;
3509   esac
3510 done
3511 else
3512   echo "$as_me: failed program was:" >&5
3513 sed 's/^/| /' conftest.$ac_ext >&5
3514
3515 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3516 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3517 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3518 See \`config.log' for more details." >&5
3519 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3520 See \`config.log' for more details." >&2;}
3521    { (exit 1); exit 1; }; }; }
3522 fi
3523
3524 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3525 fi
3526 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3527 echo "${ECHO_T}$ac_cv_objext" >&6
3528 OBJEXT=$ac_cv_objext
3529 ac_objext=$OBJEXT
3530 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3531 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3532 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3533   echo $ECHO_N "(cached) $ECHO_C" >&6
3534 else
3535   cat >conftest.$ac_ext <<_ACEOF
3536 /* confdefs.h.  */
3537 _ACEOF
3538 cat confdefs.h >>conftest.$ac_ext
3539 cat >>conftest.$ac_ext <<_ACEOF
3540 /* end confdefs.h.  */
3541
3542 int
3543 main ()
3544 {
3545 #ifndef __GNUC__
3546        choke me
3547 #endif
3548
3549   ;
3550   return 0;
3551 }
3552 _ACEOF
3553 rm -f conftest.$ac_objext
3554 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3555   (eval $ac_compile) 2>conftest.er1
3556   ac_status=$?
3557   grep -v '^ *+' conftest.er1 >conftest.err
3558   rm -f conftest.er1
3559   cat conftest.err >&5
3560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3561   (exit $ac_status); } &&
3562          { ac_try='test -z "$ac_c_werror_flag"
3563                          || test ! -s conftest.err'
3564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3565   (eval $ac_try) 2>&5
3566   ac_status=$?
3567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3568   (exit $ac_status); }; } &&
3569          { ac_try='test -s conftest.$ac_objext'
3570   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3571   (eval $ac_try) 2>&5
3572   ac_status=$?
3573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3574   (exit $ac_status); }; }; then
3575   ac_compiler_gnu=yes
3576 else
3577   echo "$as_me: failed program was:" >&5
3578 sed 's/^/| /' conftest.$ac_ext >&5
3579
3580 ac_compiler_gnu=no
3581 fi
3582 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3583 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3584
3585 fi
3586 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3587 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3588 GCC=`test $ac_compiler_gnu = yes && echo yes`
3589 ac_test_CFLAGS=${CFLAGS+set}
3590 ac_save_CFLAGS=$CFLAGS
3591 CFLAGS="-g"
3592 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3593 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3594 if test "${ac_cv_prog_cc_g+set}" = set; then
3595   echo $ECHO_N "(cached) $ECHO_C" >&6
3596 else
3597   cat >conftest.$ac_ext <<_ACEOF
3598 /* confdefs.h.  */
3599 _ACEOF
3600 cat confdefs.h >>conftest.$ac_ext
3601 cat >>conftest.$ac_ext <<_ACEOF
3602 /* end confdefs.h.  */
3603
3604 int
3605 main ()
3606 {
3607
3608   ;
3609   return 0;
3610 }
3611 _ACEOF
3612 rm -f conftest.$ac_objext
3613 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3614   (eval $ac_compile) 2>conftest.er1
3615   ac_status=$?
3616   grep -v '^ *+' conftest.er1 >conftest.err
3617   rm -f conftest.er1
3618   cat conftest.err >&5
3619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3620   (exit $ac_status); } &&
3621          { ac_try='test -z "$ac_c_werror_flag"
3622                          || test ! -s conftest.err'
3623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3624   (eval $ac_try) 2>&5
3625   ac_status=$?
3626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3627   (exit $ac_status); }; } &&
3628          { ac_try='test -s conftest.$ac_objext'
3629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3630   (eval $ac_try) 2>&5
3631   ac_status=$?
3632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3633   (exit $ac_status); }; }; then
3634   ac_cv_prog_cc_g=yes
3635 else
3636   echo "$as_me: failed program was:" >&5
3637 sed 's/^/| /' conftest.$ac_ext >&5
3638
3639 ac_cv_prog_cc_g=no
3640 fi
3641 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3642 fi
3643 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3644 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3645 if test "$ac_test_CFLAGS" = set; then
3646   CFLAGS=$ac_save_CFLAGS
3647 elif test $ac_cv_prog_cc_g = yes; then
3648   if test "$GCC" = yes; then
3649     CFLAGS="-g -O2"
3650   else
3651     CFLAGS="-g"
3652   fi
3653 else
3654   if test "$GCC" = yes; then
3655     CFLAGS="-O2"
3656   else
3657     CFLAGS=
3658   fi
3659 fi
3660 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3661 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3662 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3663   echo $ECHO_N "(cached) $ECHO_C" >&6
3664 else
3665   ac_cv_prog_cc_stdc=no
3666 ac_save_CC=$CC
3667 cat >conftest.$ac_ext <<_ACEOF
3668 /* confdefs.h.  */
3669 _ACEOF
3670 cat confdefs.h >>conftest.$ac_ext
3671 cat >>conftest.$ac_ext <<_ACEOF
3672 /* end confdefs.h.  */
3673 #include <stdarg.h>
3674 #include <stdio.h>
3675 #include <sys/types.h>
3676 #include <sys/stat.h>
3677 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3678 struct buf { int x; };
3679 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3680 static char *e (p, i)
3681      char **p;
3682      int i;
3683 {
3684   return p[i];
3685 }
3686 static char *f (char * (*g) (char **, int), char **p, ...)
3687 {
3688   char *s;
3689   va_list v;
3690   va_start (v,p);
3691   s = g (p, va_arg (v,int));
3692   va_end (v);
3693   return s;
3694 }
3695
3696 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3697    function prototypes and stuff, but not '\xHH' hex character constants.
3698    These don't provoke an error unfortunately, instead are silently treated
3699    as 'x'.  The following induces an error, until -std1 is added to get
3700    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3701    array size at least.  It's necessary to write '\x00'==0 to get something
3702    that's true only with -std1.  */
3703 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3704
3705 int test (int i, double x);
3706 struct s1 {int (*f) (int a);};
3707 struct s2 {int (*f) (double a);};
3708 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3709 int argc;
3710 char **argv;
3711 int
3712 main ()
3713 {
3714 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3715   ;
3716   return 0;
3717 }
3718 _ACEOF
3719 # Don't try gcc -ansi; that turns off useful extensions and
3720 # breaks some systems' header files.
3721 # AIX                   -qlanglvl=ansi
3722 # Ultrix and OSF/1      -std1
3723 # HP-UX 10.20 and later -Ae
3724 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3725 # SVR4                  -Xc -D__EXTENSIONS__
3726 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3727 do
3728   CC="$ac_save_CC $ac_arg"
3729   rm -f conftest.$ac_objext
3730 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3731   (eval $ac_compile) 2>conftest.er1
3732   ac_status=$?
3733   grep -v '^ *+' conftest.er1 >conftest.err
3734   rm -f conftest.er1
3735   cat conftest.err >&5
3736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3737   (exit $ac_status); } &&
3738          { ac_try='test -z "$ac_c_werror_flag"
3739                          || test ! -s conftest.err'
3740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3741   (eval $ac_try) 2>&5
3742   ac_status=$?
3743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3744   (exit $ac_status); }; } &&
3745          { ac_try='test -s conftest.$ac_objext'
3746   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3747   (eval $ac_try) 2>&5
3748   ac_status=$?
3749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3750   (exit $ac_status); }; }; then
3751   ac_cv_prog_cc_stdc=$ac_arg
3752 break
3753 else
3754   echo "$as_me: failed program was:" >&5
3755 sed 's/^/| /' conftest.$ac_ext >&5
3756
3757 fi
3758 rm -f conftest.err conftest.$ac_objext
3759 done
3760 rm -f conftest.$ac_ext conftest.$ac_objext
3761 CC=$ac_save_CC
3762
3763 fi
3764
3765 case "x$ac_cv_prog_cc_stdc" in
3766   x|xno)
3767     echo "$as_me:$LINENO: result: none needed" >&5
3768 echo "${ECHO_T}none needed" >&6 ;;
3769   *)
3770     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3771 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3772     CC="$CC $ac_cv_prog_cc_stdc" ;;
3773 esac
3774
3775 # Some people use a C++ compiler to compile C.  Since we use `exit',
3776 # in C++ we need to declare it.  In case someone uses the same compiler
3777 # for both compiling C and C++ we need to have the C++ compiler decide
3778 # the declaration of exit, since it's the most demanding environment.
3779 cat >conftest.$ac_ext <<_ACEOF
3780 #ifndef __cplusplus
3781   choke me
3782 #endif
3783 _ACEOF
3784 rm -f conftest.$ac_objext
3785 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3786   (eval $ac_compile) 2>conftest.er1
3787   ac_status=$?
3788   grep -v '^ *+' conftest.er1 >conftest.err
3789   rm -f conftest.er1
3790   cat conftest.err >&5
3791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3792   (exit $ac_status); } &&
3793          { ac_try='test -z "$ac_c_werror_flag"
3794                          || test ! -s conftest.err'
3795   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3796   (eval $ac_try) 2>&5
3797   ac_status=$?
3798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3799   (exit $ac_status); }; } &&
3800          { ac_try='test -s conftest.$ac_objext'
3801   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3802   (eval $ac_try) 2>&5
3803   ac_status=$?
3804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3805   (exit $ac_status); }; }; then
3806   for ac_declaration in \
3807    '' \
3808    'extern "C" void std::exit (int) throw (); using std::exit;' \
3809    'extern "C" void std::exit (int); using std::exit;' \
3810    'extern "C" void exit (int) throw ();' \
3811    'extern "C" void exit (int);' \
3812    'void exit (int);'
3813 do
3814   cat >conftest.$ac_ext <<_ACEOF
3815 /* confdefs.h.  */
3816 _ACEOF
3817 cat confdefs.h >>conftest.$ac_ext
3818 cat >>conftest.$ac_ext <<_ACEOF
3819 /* end confdefs.h.  */
3820 $ac_declaration
3821 #include <stdlib.h>
3822 int
3823 main ()
3824 {
3825 exit (42);
3826   ;
3827   return 0;
3828 }
3829 _ACEOF
3830 rm -f conftest.$ac_objext
3831 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3832   (eval $ac_compile) 2>conftest.er1
3833   ac_status=$?
3834   grep -v '^ *+' conftest.er1 >conftest.err
3835   rm -f conftest.er1
3836   cat conftest.err >&5
3837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3838   (exit $ac_status); } &&
3839          { ac_try='test -z "$ac_c_werror_flag"
3840                          || test ! -s conftest.err'
3841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3842   (eval $ac_try) 2>&5
3843   ac_status=$?
3844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3845   (exit $ac_status); }; } &&
3846          { ac_try='test -s conftest.$ac_objext'
3847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3848   (eval $ac_try) 2>&5
3849   ac_status=$?
3850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3851   (exit $ac_status); }; }; then
3852   :
3853 else
3854   echo "$as_me: failed program was:" >&5
3855 sed 's/^/| /' conftest.$ac_ext >&5
3856
3857 continue
3858 fi
3859 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3860   cat >conftest.$ac_ext <<_ACEOF
3861 /* confdefs.h.  */
3862 _ACEOF
3863 cat confdefs.h >>conftest.$ac_ext
3864 cat >>conftest.$ac_ext <<_ACEOF
3865 /* end confdefs.h.  */
3866 $ac_declaration
3867 int
3868 main ()
3869 {
3870 exit (42);
3871   ;
3872   return 0;
3873 }
3874 _ACEOF
3875 rm -f conftest.$ac_objext
3876 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3877   (eval $ac_compile) 2>conftest.er1
3878   ac_status=$?
3879   grep -v '^ *+' conftest.er1 >conftest.err
3880   rm -f conftest.er1
3881   cat conftest.err >&5
3882   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3883   (exit $ac_status); } &&
3884          { ac_try='test -z "$ac_c_werror_flag"
3885                          || test ! -s conftest.err'
3886   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3887   (eval $ac_try) 2>&5
3888   ac_status=$?
3889   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3890   (exit $ac_status); }; } &&
3891          { ac_try='test -s conftest.$ac_objext'
3892   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3893   (eval $ac_try) 2>&5
3894   ac_status=$?
3895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3896   (exit $ac_status); }; }; then
3897   break
3898 else
3899   echo "$as_me: failed program was:" >&5
3900 sed 's/^/| /' conftest.$ac_ext >&5
3901
3902 fi
3903 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3904 done
3905 rm -f conftest*
3906 if test -n "$ac_declaration"; then
3907   echo '#ifdef __cplusplus' >>confdefs.h
3908   echo $ac_declaration      >>confdefs.h
3909   echo '#endif'             >>confdefs.h
3910 fi
3911
3912 else
3913   echo "$as_me: failed program was:" >&5
3914 sed 's/^/| /' conftest.$ac_ext >&5
3915
3916 fi
3917 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3918 ac_ext=c
3919 ac_cpp='$CPP $CPPFLAGS'
3920 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3921 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3922 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3923
3924 ac_ext=cc
3925 ac_cpp='$CXXCPP $CPPFLAGS'
3926 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3927 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3928 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3929 if test -n "$ac_tool_prefix"; then
3930   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3931   do
3932     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3933 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3934 echo "$as_me:$LINENO: checking for $ac_word" >&5
3935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3936 if test "${ac_cv_prog_CXX+set}" = set; then
3937   echo $ECHO_N "(cached) $ECHO_C" >&6
3938 else
3939   if test -n "$CXX"; then
3940   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3941 else
3942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3943 for as_dir in $PATH
3944 do
3945   IFS=$as_save_IFS
3946   test -z "$as_dir" && as_dir=.
3947   for ac_exec_ext in '' $ac_executable_extensions; do
3948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3949     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3951     break 2
3952   fi
3953 done
3954 done
3955
3956 fi
3957 fi
3958 CXX=$ac_cv_prog_CXX
3959 if test -n "$CXX"; then
3960   echo "$as_me:$LINENO: result: $CXX" >&5
3961 echo "${ECHO_T}$CXX" >&6
3962 else
3963   echo "$as_me:$LINENO: result: no" >&5
3964 echo "${ECHO_T}no" >&6
3965 fi
3966
3967     test -n "$CXX" && break
3968   done
3969 fi
3970 if test -z "$CXX"; then
3971   ac_ct_CXX=$CXX
3972   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3973 do
3974   # Extract the first word of "$ac_prog", so it can be a program name with args.
3975 set dummy $ac_prog; ac_word=$2
3976 echo "$as_me:$LINENO: checking for $ac_word" >&5
3977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3978 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3979   echo $ECHO_N "(cached) $ECHO_C" >&6
3980 else
3981   if test -n "$ac_ct_CXX"; then
3982   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3983 else
3984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3985 for as_dir in $PATH
3986 do
3987   IFS=$as_save_IFS
3988   test -z "$as_dir" && as_dir=.
3989   for ac_exec_ext in '' $ac_executable_extensions; do
3990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3991     ac_cv_prog_ac_ct_CXX="$ac_prog"
3992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3993     break 2
3994   fi
3995 done
3996 done
3997
3998 fi
3999 fi
4000 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
4001 if test -n "$ac_ct_CXX"; then
4002   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
4003 echo "${ECHO_T}$ac_ct_CXX" >&6
4004 else
4005   echo "$as_me:$LINENO: result: no" >&5
4006 echo "${ECHO_T}no" >&6
4007 fi
4008
4009   test -n "$ac_ct_CXX" && break
4010 done
4011 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
4012
4013   CXX=$ac_ct_CXX
4014 fi
4015
4016
4017 # Provide some information about the compiler.
4018 echo "$as_me:$LINENO:" \
4019      "checking for C++ compiler version" >&5
4020 ac_compiler=`set X $ac_compile; echo $2`
4021 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4022   (eval $ac_compiler --version </dev/null >&5) 2>&5
4023   ac_status=$?
4024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4025   (exit $ac_status); }
4026 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4027   (eval $ac_compiler -v </dev/null >&5) 2>&5
4028   ac_status=$?
4029   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4030   (exit $ac_status); }
4031 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4032   (eval $ac_compiler -V </dev/null >&5) 2>&5
4033   ac_status=$?
4034   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4035   (exit $ac_status); }
4036
4037 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4038 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4039 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4040   echo $ECHO_N "(cached) $ECHO_C" >&6
4041 else
4042   cat >conftest.$ac_ext <<_ACEOF
4043 /* confdefs.h.  */
4044 _ACEOF
4045 cat confdefs.h >>conftest.$ac_ext
4046 cat >>conftest.$ac_ext <<_ACEOF
4047 /* end confdefs.h.  */
4048
4049 int
4050 main ()
4051 {
4052 #ifndef __GNUC__
4053        choke me
4054 #endif
4055
4056   ;
4057   return 0;
4058 }
4059 _ACEOF
4060 rm -f conftest.$ac_objext
4061 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4062   (eval $ac_compile) 2>conftest.er1
4063   ac_status=$?
4064   grep -v '^ *+' conftest.er1 >conftest.err
4065   rm -f conftest.er1
4066   cat conftest.err >&5
4067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4068   (exit $ac_status); } &&
4069          { ac_try='test -z "$ac_cxx_werror_flag"
4070                          || test ! -s conftest.err'
4071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4072   (eval $ac_try) 2>&5
4073   ac_status=$?
4074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4075   (exit $ac_status); }; } &&
4076          { ac_try='test -s conftest.$ac_objext'
4077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4078   (eval $ac_try) 2>&5
4079   ac_status=$?
4080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4081   (exit $ac_status); }; }; then
4082   ac_compiler_gnu=yes
4083 else
4084   echo "$as_me: failed program was:" >&5
4085 sed 's/^/| /' conftest.$ac_ext >&5
4086
4087 ac_compiler_gnu=no
4088 fi
4089 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4090 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4091
4092 fi
4093 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4094 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4095 GXX=`test $ac_compiler_gnu = yes && echo yes`
4096 ac_test_CXXFLAGS=${CXXFLAGS+set}
4097 ac_save_CXXFLAGS=$CXXFLAGS
4098 CXXFLAGS="-g"
4099 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4100 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4101 if test "${ac_cv_prog_cxx_g+set}" = set; then
4102   echo $ECHO_N "(cached) $ECHO_C" >&6
4103 else
4104   cat >conftest.$ac_ext <<_ACEOF
4105 /* confdefs.h.  */
4106 _ACEOF
4107 cat confdefs.h >>conftest.$ac_ext
4108 cat >>conftest.$ac_ext <<_ACEOF
4109 /* end confdefs.h.  */
4110
4111 int
4112 main ()
4113 {
4114
4115   ;
4116   return 0;
4117 }
4118 _ACEOF
4119 rm -f conftest.$ac_objext
4120 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4121   (eval $ac_compile) 2>conftest.er1
4122   ac_status=$?
4123   grep -v '^ *+' conftest.er1 >conftest.err
4124   rm -f conftest.er1
4125   cat conftest.err >&5
4126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4127   (exit $ac_status); } &&
4128          { ac_try='test -z "$ac_cxx_werror_flag"
4129                          || test ! -s conftest.err'
4130   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4131   (eval $ac_try) 2>&5
4132   ac_status=$?
4133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4134   (exit $ac_status); }; } &&
4135          { ac_try='test -s conftest.$ac_objext'
4136   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4137   (eval $ac_try) 2>&5
4138   ac_status=$?
4139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4140   (exit $ac_status); }; }; then
4141   ac_cv_prog_cxx_g=yes
4142 else
4143   echo "$as_me: failed program was:" >&5
4144 sed 's/^/| /' conftest.$ac_ext >&5
4145
4146 ac_cv_prog_cxx_g=no
4147 fi
4148 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4149 fi
4150 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4151 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4152 if test "$ac_test_CXXFLAGS" = set; then
4153   CXXFLAGS=$ac_save_CXXFLAGS
4154 elif test $ac_cv_prog_cxx_g = yes; then
4155   if test "$GXX" = yes; then
4156     CXXFLAGS="-g -O2"
4157   else
4158     CXXFLAGS="-g"
4159   fi
4160 else
4161   if test "$GXX" = yes; then
4162     CXXFLAGS="-O2"
4163   else
4164     CXXFLAGS=
4165   fi
4166 fi
4167 for ac_declaration in \
4168    '' \
4169    'extern "C" void std::exit (int) throw (); using std::exit;' \
4170    'extern "C" void std::exit (int); using std::exit;' \
4171    'extern "C" void exit (int) throw ();' \
4172    'extern "C" void exit (int);' \
4173    'void exit (int);'
4174 do
4175   cat >conftest.$ac_ext <<_ACEOF
4176 /* confdefs.h.  */
4177 _ACEOF
4178 cat confdefs.h >>conftest.$ac_ext
4179 cat >>conftest.$ac_ext <<_ACEOF
4180 /* end confdefs.h.  */
4181 $ac_declaration
4182 #include <stdlib.h>
4183 int
4184 main ()
4185 {
4186 exit (42);
4187   ;
4188   return 0;
4189 }
4190 _ACEOF
4191 rm -f conftest.$ac_objext
4192 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4193   (eval $ac_compile) 2>conftest.er1
4194   ac_status=$?
4195   grep -v '^ *+' conftest.er1 >conftest.err
4196   rm -f conftest.er1
4197   cat conftest.err >&5
4198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4199   (exit $ac_status); } &&
4200          { ac_try='test -z "$ac_cxx_werror_flag"
4201                          || test ! -s conftest.err'
4202   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4203   (eval $ac_try) 2>&5
4204   ac_status=$?
4205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4206   (exit $ac_status); }; } &&
4207          { ac_try='test -s conftest.$ac_objext'
4208   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4209   (eval $ac_try) 2>&5
4210   ac_status=$?
4211   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4212   (exit $ac_status); }; }; then
4213   :
4214 else
4215   echo "$as_me: failed program was:" >&5
4216 sed 's/^/| /' conftest.$ac_ext >&5
4217
4218 continue
4219 fi
4220 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4221   cat >conftest.$ac_ext <<_ACEOF
4222 /* confdefs.h.  */
4223 _ACEOF
4224 cat confdefs.h >>conftest.$ac_ext
4225 cat >>conftest.$ac_ext <<_ACEOF
4226 /* end confdefs.h.  */
4227 $ac_declaration
4228 int
4229 main ()
4230 {
4231 exit (42);
4232   ;
4233   return 0;
4234 }
4235 _ACEOF
4236 rm -f conftest.$ac_objext
4237 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4238   (eval $ac_compile) 2>conftest.er1
4239   ac_status=$?
4240   grep -v '^ *+' conftest.er1 >conftest.err
4241   rm -f conftest.er1
4242   cat conftest.err >&5
4243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4244   (exit $ac_status); } &&
4245          { ac_try='test -z "$ac_cxx_werror_flag"
4246                          || test ! -s conftest.err'
4247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4248   (eval $ac_try) 2>&5
4249   ac_status=$?
4250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4251   (exit $ac_status); }; } &&
4252          { ac_try='test -s conftest.$ac_objext'
4253   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4254   (eval $ac_try) 2>&5
4255   ac_status=$?
4256   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4257   (exit $ac_status); }; }; then
4258   break
4259 else
4260   echo "$as_me: failed program was:" >&5
4261 sed 's/^/| /' conftest.$ac_ext >&5
4262
4263 fi
4264 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4265 done
4266 rm -f conftest*
4267 if test -n "$ac_declaration"; then
4268   echo '#ifdef __cplusplus' >>confdefs.h
4269   echo $ac_declaration      >>confdefs.h
4270   echo '#endif'             >>confdefs.h
4271 fi
4272
4273 ac_ext=c
4274 ac_cpp='$CPP $CPPFLAGS'
4275 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4276 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4277 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4278
4279
4280 # We must set the default linker to the linker used by gcc for the correct
4281 # operation of libtool.  If LD is not defined and we are using gcc, try to
4282 # set the LD default to the ld used by gcc.
4283 if test -z "$LD"; then
4284   if test "$GCC" = yes; then
4285     case $build in
4286     *-*-mingw*)
4287       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4288     *)
4289       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4290     esac
4291     case $gcc_prog_ld in
4292     # Accept absolute paths.
4293     [\\/]* | [A-Za-z]:[\\/]*)
4294       LD="$gcc_prog_ld" ;;
4295     esac
4296   fi
4297 fi
4298
4299
4300
4301
4302 if test -n "$ac_tool_prefix"; then
4303   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4304 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4305 echo "$as_me:$LINENO: checking for $ac_word" >&5
4306 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4307 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4308   echo $ECHO_N "(cached) $ECHO_C" >&6
4309 else
4310   if test -n "$GNATBIND"; then
4311   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4312 else
4313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4314 for as_dir in $PATH
4315 do
4316   IFS=$as_save_IFS
4317   test -z "$as_dir" && as_dir=.
4318   for ac_exec_ext in '' $ac_executable_extensions; do
4319   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4320     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4321     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4322     break 2
4323   fi
4324 done
4325 done
4326
4327 fi
4328 fi
4329 GNATBIND=$ac_cv_prog_GNATBIND
4330 if test -n "$GNATBIND"; then
4331   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4332 echo "${ECHO_T}$GNATBIND" >&6
4333 else
4334   echo "$as_me:$LINENO: result: no" >&5
4335 echo "${ECHO_T}no" >&6
4336 fi
4337
4338 fi
4339 if test -z "$ac_cv_prog_GNATBIND"; then
4340   ac_ct_GNATBIND=$GNATBIND
4341   # Extract the first word of "gnatbind", so it can be a program name with args.
4342 set dummy gnatbind; ac_word=$2
4343 echo "$as_me:$LINENO: checking for $ac_word" >&5
4344 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4345 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4346   echo $ECHO_N "(cached) $ECHO_C" >&6
4347 else
4348   if test -n "$ac_ct_GNATBIND"; then
4349   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4350 else
4351 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4352 for as_dir in $PATH
4353 do
4354   IFS=$as_save_IFS
4355   test -z "$as_dir" && as_dir=.
4356   for ac_exec_ext in '' $ac_executable_extensions; do
4357   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4358     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4359     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4360     break 2
4361   fi
4362 done
4363 done
4364
4365   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4366 fi
4367 fi
4368 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4369 if test -n "$ac_ct_GNATBIND"; then
4370   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4371 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4372 else
4373   echo "$as_me:$LINENO: result: no" >&5
4374 echo "${ECHO_T}no" >&6
4375 fi
4376
4377   GNATBIND=$ac_ct_GNATBIND
4378 else
4379   GNATBIND="$ac_cv_prog_GNATBIND"
4380 fi
4381
4382 if test -n "$ac_tool_prefix"; then
4383   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4384 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4385 echo "$as_me:$LINENO: checking for $ac_word" >&5
4386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4387 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4388   echo $ECHO_N "(cached) $ECHO_C" >&6
4389 else
4390   if test -n "$GNATMAKE"; then
4391   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4392 else
4393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4394 for as_dir in $PATH
4395 do
4396   IFS=$as_save_IFS
4397   test -z "$as_dir" && as_dir=.
4398   for ac_exec_ext in '' $ac_executable_extensions; do
4399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4400     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4402     break 2
4403   fi
4404 done
4405 done
4406
4407 fi
4408 fi
4409 GNATMAKE=$ac_cv_prog_GNATMAKE
4410 if test -n "$GNATMAKE"; then
4411   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4412 echo "${ECHO_T}$GNATMAKE" >&6
4413 else
4414   echo "$as_me:$LINENO: result: no" >&5
4415 echo "${ECHO_T}no" >&6
4416 fi
4417
4418 fi
4419 if test -z "$ac_cv_prog_GNATMAKE"; then
4420   ac_ct_GNATMAKE=$GNATMAKE
4421   # Extract the first word of "gnatmake", so it can be a program name with args.
4422 set dummy gnatmake; ac_word=$2
4423 echo "$as_me:$LINENO: checking for $ac_word" >&5
4424 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4425 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4426   echo $ECHO_N "(cached) $ECHO_C" >&6
4427 else
4428   if test -n "$ac_ct_GNATMAKE"; then
4429   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4430 else
4431 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4432 for as_dir in $PATH
4433 do
4434   IFS=$as_save_IFS
4435   test -z "$as_dir" && as_dir=.
4436   for ac_exec_ext in '' $ac_executable_extensions; do
4437   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4438     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4439     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4440     break 2
4441   fi
4442 done
4443 done
4444
4445   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4446 fi
4447 fi
4448 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4449 if test -n "$ac_ct_GNATMAKE"; then
4450   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4451 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4452 else
4453   echo "$as_me:$LINENO: result: no" >&5
4454 echo "${ECHO_T}no" >&6
4455 fi
4456
4457   GNATMAKE=$ac_ct_GNATMAKE
4458 else
4459   GNATMAKE="$ac_cv_prog_GNATMAKE"
4460 fi
4461
4462 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4463 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4464 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4465   echo $ECHO_N "(cached) $ECHO_C" >&6
4466 else
4467   cat >conftest.adb <<EOF
4468 procedure conftest is begin null; end conftest;
4469 EOF
4470 acx_cv_cc_gcc_supports_ada=no
4471 # There is a bug in old released versions of GCC which causes the
4472 # driver to exit successfully when the appropriate language module
4473 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4474 # Therefore we must check for the error message as well as an
4475 # unsuccessful exit.
4476 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4477 # given a .adb file, but produce no object file.  So we must check
4478 # if an object file was really produced to guard against this.
4479 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4480 if test x"$errors" = x && test -f conftest.$ac_objext; then
4481   acx_cv_cc_gcc_supports_ada=yes
4482 fi
4483 rm -f conftest.*
4484 fi
4485 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4486 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4487
4488 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4489   have_gnat=yes
4490 else
4491   have_gnat=no
4492 fi
4493
4494 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4495 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4496 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4497   echo $ECHO_N "(cached) $ECHO_C" >&6
4498 else
4499    echo abfoo >t1
4500   echo cdfoo >t2
4501   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4502   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4503     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4504       :
4505     else
4506       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4507     fi
4508   fi
4509   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4510     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4511       :
4512     else
4513       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4514     fi
4515   fi
4516   rm t1 t2
4517
4518 fi
4519 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4520 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4521 do_compare="$gcc_cv_prog_cmp_skip"
4522
4523
4524
4525 # See if we are building gcc with C++.
4526 # Check whether --enable-build-with-cxx or --disable-build-with-cxx was given.
4527 if test "${enable_build_with_cxx+set}" = set; then
4528   enableval="$enable_build_with_cxx"
4529   ENABLE_BUILD_WITH_CXX=$enableval
4530 else
4531   ENABLE_BUILD_WITH_CXX=no
4532 fi;
4533
4534 # Check for GMP, MPFR and MPC
4535 gmplibs="-lmpfr -lgmp"
4536 gmpinc=
4537 have_gmp=no
4538 mpclibs=-lmpc
4539 mpcinc=
4540 have_mpc=no
4541
4542 # Specify a location for mpc
4543 # check for this first so it ends up on the link line before mpfr.
4544
4545 # Check whether --with-mpc or --without-mpc was given.
4546 if test "${with_mpc+set}" = set; then
4547   withval="$with_mpc"
4548
4549 fi;
4550
4551 # Check whether --with-mpc_include or --without-mpc_include was given.
4552 if test "${with_mpc_include+set}" = set; then
4553   withval="$with_mpc_include"
4554
4555 fi;
4556
4557 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4558 if test "${with_mpc_lib+set}" = set; then
4559   withval="$with_mpc_lib"
4560
4561 fi;
4562
4563 if test "x$with_mpc" != x; then
4564   mpclibs="-L$with_mpc/lib -lmpc"
4565   mpcinc="-I$with_mpc/include $mpcinc"
4566 fi
4567 if test "x$with_mpc_include" != x; then
4568   mpcinc="-I$with_mpc_include $mpcinc"
4569 fi
4570 if test "x$with_mpc_lib" != x; then
4571   mpclibs="-L$with_mpc_lib -lmpc"
4572 fi
4573 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4574   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4575   mpcinc='-I$$s/mpc/src '"$mpcinc"
4576   # Do not test the mpc version.  Assume that it is sufficient, since
4577   # it is in the source tree, and the library has not been built yet
4578   # but it would be included on the link line in the version check below
4579   # hence making the test fail.
4580   have_mpc=yes
4581 fi
4582
4583 # Specify a location for mpfr
4584 # check for this first so it ends up on the link line before gmp.
4585
4586 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4587 if test "${with_mpfr_dir+set}" = set; then
4588   withval="$with_mpfr_dir"
4589   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4590 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4591 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4592 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4593    { (exit 1); exit 1; }; }
4594 fi;
4595
4596
4597 # Check whether --with-mpfr or --without-mpfr was given.
4598 if test "${with_mpfr+set}" = set; then
4599   withval="$with_mpfr"
4600
4601 fi;
4602
4603 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4604 if test "${with_mpfr_include+set}" = set; then
4605   withval="$with_mpfr_include"
4606
4607 fi;
4608
4609 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4610 if test "${with_mpfr_lib+set}" = set; then
4611   withval="$with_mpfr_lib"
4612
4613 fi;
4614
4615 if test "x$with_mpfr" != x; then
4616   gmplibs="-L$with_mpfr/lib $gmplibs"
4617   gmpinc="-I$with_mpfr/include"
4618 fi
4619 if test "x$with_mpfr_include" != x; then
4620   gmpinc="-I$with_mpfr_include"
4621 fi
4622 if test "x$with_mpfr_lib" != x; then
4623   gmplibs="-L$with_mpfr_lib $gmplibs"
4624 fi
4625 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4626   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4627   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4628   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4629   # Do not test the mpfr version.  Assume that it is sufficient, since
4630   # it is in the source tree, and the library has not been built yet
4631   # but it would be included on the link line in the version check below
4632   # hence making the test fail.
4633   have_gmp=yes
4634 fi
4635
4636 # Specify a location for gmp
4637
4638 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4639 if test "${with_gmp_dir+set}" = set; then
4640   withval="$with_gmp_dir"
4641   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4642 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4643 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4644 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4645    { (exit 1); exit 1; }; }
4646 fi;
4647
4648
4649 # Check whether --with-gmp or --without-gmp was given.
4650 if test "${with_gmp+set}" = set; then
4651   withval="$with_gmp"
4652
4653 fi;
4654
4655 # Check whether --with-gmp_include or --without-gmp_include was given.
4656 if test "${with_gmp_include+set}" = set; then
4657   withval="$with_gmp_include"
4658
4659 fi;
4660
4661 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4662 if test "${with_gmp_lib+set}" = set; then
4663   withval="$with_gmp_lib"
4664
4665 fi;
4666
4667
4668 if test "x$with_gmp" != x; then
4669   gmplibs="-L$with_gmp/lib $gmplibs"
4670   gmpinc="-I$with_gmp/include $gmpinc"
4671 fi
4672 if test "x$with_gmp_include" != x; then
4673   gmpinc="-I$with_gmp_include $gmpinc"
4674 fi
4675 if test "x$with_gmp_lib" != x; then
4676   gmplibs="-L$with_gmp_lib $gmplibs"
4677 fi
4678 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4679   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4680   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4681   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4682   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4683   # Do not test the gmp version.  Assume that it is sufficient, since
4684   # it is in the source tree, and the library has not been built yet
4685   # but it would be included on the link line in the version check below
4686   # hence making the test fail.
4687   have_gmp=yes
4688 fi
4689
4690 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4691   have_gmp=yes
4692   saved_CFLAGS="$CFLAGS"
4693   CFLAGS="$CFLAGS $gmpinc"
4694   # Check GMP actually works
4695   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4696 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4697
4698 cat >conftest.$ac_ext <<_ACEOF
4699 /* confdefs.h.  */
4700 _ACEOF
4701 cat confdefs.h >>conftest.$ac_ext
4702 cat >>conftest.$ac_ext <<_ACEOF
4703 /* end confdefs.h.  */
4704 #include "gmp.h"
4705 int
4706 main ()
4707 {
4708
4709   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4710   choke me
4711   #endif
4712
4713   ;
4714   return 0;
4715 }
4716 _ACEOF
4717 rm -f conftest.$ac_objext
4718 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4719   (eval $ac_compile) 2>conftest.er1
4720   ac_status=$?
4721   grep -v '^ *+' conftest.er1 >conftest.err
4722   rm -f conftest.er1
4723   cat conftest.err >&5
4724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4725   (exit $ac_status); } &&
4726          { ac_try='test -z "$ac_c_werror_flag"
4727                          || test ! -s conftest.err'
4728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4729   (eval $ac_try) 2>&5
4730   ac_status=$?
4731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4732   (exit $ac_status); }; } &&
4733          { ac_try='test -s conftest.$ac_objext'
4734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4735   (eval $ac_try) 2>&5
4736   ac_status=$?
4737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4738   (exit $ac_status); }; }; then
4739   echo "$as_me:$LINENO: result: yes" >&5
4740 echo "${ECHO_T}yes" >&6
4741 else
4742   echo "$as_me: failed program was:" >&5
4743 sed 's/^/| /' conftest.$ac_ext >&5
4744
4745 echo "$as_me:$LINENO: result: no" >&5
4746 echo "${ECHO_T}no" >&6; have_gmp=no
4747 fi
4748 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4749
4750   # If we have GMP, check the MPFR version.
4751   if test x"$have_gmp" = xyes; then
4752         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4753 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4754     cat >conftest.$ac_ext <<_ACEOF
4755 /* confdefs.h.  */
4756 _ACEOF
4757 cat confdefs.h >>conftest.$ac_ext
4758 cat >>conftest.$ac_ext <<_ACEOF
4759 /* end confdefs.h.  */
4760 #include <gmp.h>
4761     #include <mpfr.h>
4762 int
4763 main ()
4764 {
4765
4766     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4767     choke me
4768     #endif
4769
4770   ;
4771   return 0;
4772 }
4773 _ACEOF
4774 rm -f conftest.$ac_objext
4775 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4776   (eval $ac_compile) 2>conftest.er1
4777   ac_status=$?
4778   grep -v '^ *+' conftest.er1 >conftest.err
4779   rm -f conftest.er1
4780   cat conftest.err >&5
4781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4782   (exit $ac_status); } &&
4783          { ac_try='test -z "$ac_c_werror_flag"
4784                          || test ! -s conftest.err'
4785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4786   (eval $ac_try) 2>&5
4787   ac_status=$?
4788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4789   (exit $ac_status); }; } &&
4790          { ac_try='test -s conftest.$ac_objext'
4791   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4792   (eval $ac_try) 2>&5
4793   ac_status=$?
4794   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4795   (exit $ac_status); }; }; then
4796   cat >conftest.$ac_ext <<_ACEOF
4797 /* confdefs.h.  */
4798 _ACEOF
4799 cat confdefs.h >>conftest.$ac_ext
4800 cat >>conftest.$ac_ext <<_ACEOF
4801 /* end confdefs.h.  */
4802 #include <gmp.h>
4803     #include <mpfr.h>
4804 int
4805 main ()
4806 {
4807
4808     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4809     choke me
4810     #endif
4811
4812   ;
4813   return 0;
4814 }
4815 _ACEOF
4816 rm -f conftest.$ac_objext
4817 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4818   (eval $ac_compile) 2>conftest.er1
4819   ac_status=$?
4820   grep -v '^ *+' conftest.er1 >conftest.err
4821   rm -f conftest.er1
4822   cat conftest.err >&5
4823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4824   (exit $ac_status); } &&
4825          { ac_try='test -z "$ac_c_werror_flag"
4826                          || test ! -s conftest.err'
4827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4828   (eval $ac_try) 2>&5
4829   ac_status=$?
4830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4831   (exit $ac_status); }; } &&
4832          { ac_try='test -s conftest.$ac_objext'
4833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4834   (eval $ac_try) 2>&5
4835   ac_status=$?
4836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4837   (exit $ac_status); }; }; then
4838   echo "$as_me:$LINENO: result: yes" >&5
4839 echo "${ECHO_T}yes" >&6
4840 else
4841   echo "$as_me: failed program was:" >&5
4842 sed 's/^/| /' conftest.$ac_ext >&5
4843
4844 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4845 echo "${ECHO_T}buggy but acceptable" >&6
4846 fi
4847 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4848 else
4849   echo "$as_me: failed program was:" >&5
4850 sed 's/^/| /' conftest.$ac_ext >&5
4851
4852 echo "$as_me:$LINENO: result: no" >&5
4853 echo "${ECHO_T}no" >&6; have_gmp=no
4854 fi
4855 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4856   fi
4857
4858   # Check for the MPC header version.
4859   if test x"$have_mpc" != xyes ; then
4860     CFLAGS="$CFLAGS $mpcinc"
4861     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4862 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4863     cat >conftest.$ac_ext <<_ACEOF
4864 /* confdefs.h.  */
4865 _ACEOF
4866 cat confdefs.h >>conftest.$ac_ext
4867 cat >>conftest.$ac_ext <<_ACEOF
4868 /* end confdefs.h.  */
4869 #include <mpc.h>
4870 int
4871 main ()
4872 {
4873
4874     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4875     choke me
4876     #endif
4877
4878   ;
4879   return 0;
4880 }
4881 _ACEOF
4882 rm -f conftest.$ac_objext
4883 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4884   (eval $ac_compile) 2>conftest.er1
4885   ac_status=$?
4886   grep -v '^ *+' conftest.er1 >conftest.err
4887   rm -f conftest.er1
4888   cat conftest.err >&5
4889   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4890   (exit $ac_status); } &&
4891          { ac_try='test -z "$ac_c_werror_flag"
4892                          || test ! -s conftest.err'
4893   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4894   (eval $ac_try) 2>&5
4895   ac_status=$?
4896   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4897   (exit $ac_status); }; } &&
4898          { ac_try='test -s conftest.$ac_objext'
4899   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4900   (eval $ac_try) 2>&5
4901   ac_status=$?
4902   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4903   (exit $ac_status); }; }; then
4904   echo "$as_me:$LINENO: result: yes" >&5
4905 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4906 else
4907   echo "$as_me: failed program was:" >&5
4908 sed 's/^/| /' conftest.$ac_ext >&5
4909
4910 echo "$as_me:$LINENO: result: no" >&5
4911 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4912 fi
4913 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4914   fi
4915
4916   # Now check the MPFR library.
4917   if test x"$have_gmp" = xyes; then
4918     saved_LIBS="$LIBS"
4919     LIBS="$LIBS $gmplibs"
4920     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4921 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4922     cat >conftest.$ac_ext <<_ACEOF
4923 /* confdefs.h.  */
4924 _ACEOF
4925 cat confdefs.h >>conftest.$ac_ext
4926 cat >>conftest.$ac_ext <<_ACEOF
4927 /* end confdefs.h.  */
4928 #include <gmp.h>
4929     #include <mpfr.h>
4930 int
4931 main ()
4932 {
4933
4934     mpfr_t n;
4935     mpfr_t x;
4936     int t;
4937     mpfr_init (n);
4938     mpfr_init (x);
4939     mpfr_atan2 (n, n, x, GMP_RNDN);
4940     mpfr_erfc (n, x, GMP_RNDN);
4941     mpfr_subnormalize (x, t, GMP_RNDN);
4942
4943   ;
4944   return 0;
4945 }
4946 _ACEOF
4947 rm -f conftest.$ac_objext conftest$ac_exeext
4948 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4949   (eval $ac_link) 2>conftest.er1
4950   ac_status=$?
4951   grep -v '^ *+' conftest.er1 >conftest.err
4952   rm -f conftest.er1
4953   cat conftest.err >&5
4954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4955   (exit $ac_status); } &&
4956          { ac_try='test -z "$ac_c_werror_flag"
4957                          || test ! -s conftest.err'
4958   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4959   (eval $ac_try) 2>&5
4960   ac_status=$?
4961   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4962   (exit $ac_status); }; } &&
4963          { ac_try='test -s conftest$ac_exeext'
4964   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4965   (eval $ac_try) 2>&5
4966   ac_status=$?
4967   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4968   (exit $ac_status); }; }; then
4969   echo "$as_me:$LINENO: result: yes" >&5
4970 echo "${ECHO_T}yes" >&6
4971 else
4972   echo "$as_me: failed program was:" >&5
4973 sed 's/^/| /' conftest.$ac_ext >&5
4974
4975 echo "$as_me:$LINENO: result: no" >&5
4976 echo "${ECHO_T}no" >&6; have_gmp=no
4977 fi
4978 rm -f conftest.err conftest.$ac_objext \
4979       conftest$ac_exeext conftest.$ac_ext
4980     LIBS="$saved_LIBS"
4981   fi
4982
4983   if test x"$have_mpc" = xmaybe; then
4984     saved_LIBS="$LIBS"
4985     LIBS="$LIBS $mpclibs $gmplibs"
4986     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4987 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4988     cat >conftest.$ac_ext <<_ACEOF
4989 /* confdefs.h.  */
4990 _ACEOF
4991 cat confdefs.h >>conftest.$ac_ext
4992 cat >>conftest.$ac_ext <<_ACEOF
4993 /* end confdefs.h.  */
4994 #include <mpc.h>
4995 int
4996 main ()
4997 {
4998
4999     mpc_t n;
5000     mpc_init2 (n, 53);
5001     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
5002     mpc_sin (n, n, MPC_RNDNN);
5003     mpc_cos (n, n, MPC_RNDNN);
5004     mpc_tan (n, n, MPC_RNDNN);
5005     mpc_sinh (n, n, MPC_RNDNN);
5006     mpc_cosh (n, n, MPC_RNDNN);
5007     mpc_tanh (n, n, MPC_RNDNN);
5008     mpc_exp (n, n, MPC_RNDNN);
5009     mpc_log (n, n, MPC_RNDNN);
5010     mpc_sqrt (n, n, MPC_RNDNN);
5011     mpc_proj (n, n, MPC_RNDNN);
5012     mpc_neg (n, n, MPC_RNDNN);
5013     mpc_sqr (n, n, MPC_RNDNN);
5014     mpc_clear (n);
5015
5016   ;
5017   return 0;
5018 }
5019 _ACEOF
5020 rm -f conftest.$ac_objext conftest$ac_exeext
5021 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5022   (eval $ac_link) 2>conftest.er1
5023   ac_status=$?
5024   grep -v '^ *+' conftest.er1 >conftest.err
5025   rm -f conftest.er1
5026   cat conftest.err >&5
5027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5028   (exit $ac_status); } &&
5029          { ac_try='test -z "$ac_c_werror_flag"
5030                          || test ! -s conftest.err'
5031   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5032   (eval $ac_try) 2>&5
5033   ac_status=$?
5034   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5035   (exit $ac_status); }; } &&
5036          { ac_try='test -s conftest$ac_exeext'
5037   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5038   (eval $ac_try) 2>&5
5039   ac_status=$?
5040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5041   (exit $ac_status); }; }; then
5042   echo "$as_me:$LINENO: result: yes" >&5
5043 echo "${ECHO_T}yes" >&6; have_mpc=yes
5044 else
5045   echo "$as_me: failed program was:" >&5
5046 sed 's/^/| /' conftest.$ac_ext >&5
5047
5048 echo "$as_me:$LINENO: result: no" >&5
5049 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5050 fi
5051 rm -f conftest.err conftest.$ac_objext \
5052       conftest$ac_exeext conftest.$ac_ext
5053     LIBS="$saved_LIBS"
5054   fi
5055
5056   CFLAGS="$saved_CFLAGS"
5057
5058   if test x$have_gmp != xyes; then
5059     { { echo "$as_me:$LINENO: 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." >&5
5067 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5068 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5069 Copies of these libraries' source code can be found at their respective
5070 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5071 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5072 If you obtained GMP and/or MPFR from a vendor distribution package, make
5073 sure that you have installed both the libraries and the header files.
5074 They may be located in separate packages." >&2;}
5075    { (exit 1); exit 1; }; }
5076   fi
5077 fi
5078
5079 if test x$have_mpc != xyes ; then
5080   mpcinc=
5081   mpclibs=
5082 fi
5083
5084 gmpinc="$mpcinc $gmpinc"
5085 gmplibs="$mpclibs $gmplibs"
5086
5087 # Flags needed for both GMP, MPFR and/or MPC.
5088
5089
5090
5091
5092
5093
5094 # Allow host libstdc++ to be specified for static linking with PPL.
5095
5096 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5097 if test "${with_host_libstdcxx+set}" = set; then
5098   withval="$with_host_libstdcxx"
5099
5100 fi;
5101
5102 case $with_host_libstdcxx in
5103   no|yes)
5104     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5105 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5106    { (exit 1); exit 1; }; }
5107     ;;
5108 esac
5109
5110 # Linker flags to use for stage1 or when not boostrapping.
5111
5112 # Check whether --with-stage1-ldflags or --without-stage1-ldflags was given.
5113 if test "${with_stage1_ldflags+set}" = set; then
5114   withval="$with_stage1_ldflags"
5115   if test "$withval" = "no" -o "$withval" = "yes"; then
5116    stage1_ldflags=
5117  else
5118    stage1_ldflags=$withval
5119  fi
5120 else
5121   stage1_ldflags=
5122 fi;
5123
5124
5125 # Libraries to use for stage1 or when not bootstrapping.
5126
5127 # Check whether --with-stage1-libs or --without-stage1-libs was given.
5128 if test "${with_stage1_libs+set}" = set; then
5129   withval="$with_stage1_libs"
5130   if test "$withval" = "no" -o "$withval" = "yes"; then
5131    stage1_libs=
5132  else
5133    stage1_libs=$withval
5134  fi
5135 else
5136   stage1_libs=$with_host_libstdcxx
5137 fi;
5138
5139
5140 # Linker flags to use for stage2 and later builds.
5141
5142 # Check whether --with-boot-ldflags or --without-boot-ldflags was given.
5143 if test "${with_boot_ldflags+set}" = set; then
5144   withval="$with_boot_ldflags"
5145   if test "$withval" = "no" -o "$withval" = "yes"; then
5146    poststage1_ldflags=
5147  else
5148    poststage1_ldflags=$withval
5149  fi
5150 else
5151   if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5152    poststage1_ldflags=-static-libstdc++
5153  else
5154    poststage1_ldflags=
5155  fi
5156 fi;
5157
5158
5159 # Libraries to use for stage2 and later builds.  This defaults to the
5160 # argument passed to --with-host-libstdcxx.
5161
5162 # Check whether --with-boot-libs or --without-boot-libs was given.
5163 if test "${with_boot_libs+set}" = set; then
5164   withval="$with_boot_libs"
5165   if test "$withval" = "no" -o "$withval" = "yes"; then
5166    poststage1_libs=
5167  else
5168    poststage1_libs=$withval
5169  fi
5170 else
5171   poststage1_libs=$with_host_libstdcxx
5172 fi;
5173
5174
5175 # Check for PPL
5176 ppl_major_version=0
5177 ppl_minor_version=10
5178 ppllibs=" -lppl_c -lppl -lgmpxx"
5179 pplinc=
5180
5181
5182 # Check whether --with-ppl or --without-ppl was given.
5183 if test "${with_ppl+set}" = set; then
5184   withval="$with_ppl"
5185
5186 else
5187   with_ppl=no
5188 fi;
5189
5190 # Check whether --with-ppl_include or --without-ppl_include was given.
5191 if test "${with_ppl_include+set}" = set; then
5192   withval="$with_ppl_include"
5193
5194 fi;
5195
5196 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5197 if test "${with_ppl_lib+set}" = set; then
5198   withval="$with_ppl_lib"
5199
5200 fi;
5201
5202 case $with_ppl in
5203   no)
5204     ppllibs=
5205     ;;
5206   *)
5207     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
5208     pplinc="-I$with_ppl/include $pplinc"
5209     LIBS="$ppllibs $LIBS"
5210     ;;
5211 esac
5212 if test "x$with_ppl_include" != x; then
5213   pplinc="-I$with_ppl_include $pplinc"
5214 fi
5215 if test "x$with_ppl_lib" != x; then
5216   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
5217   LIBS="$ppllibs $LIBS"
5218 fi
5219 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5220   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
5221   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5222   LIBS="$ppllibs $LIBS"
5223 fi
5224
5225 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5226 if test "${enable_ppl_version_check+set}" = set; then
5227   enableval="$enable_ppl_version_check"
5228   ENABLE_PPL_CHECK=$enableval
5229 else
5230   ENABLE_PPL_CHECK=yes
5231 fi;
5232
5233 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5234   saved_CFLAGS="$CFLAGS"
5235   CFLAGS="$CFLAGS $pplinc $gmpinc"
5236   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5237 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5238   cat >conftest.$ac_ext <<_ACEOF
5239 /* confdefs.h.  */
5240 _ACEOF
5241 cat confdefs.h >>conftest.$ac_ext
5242 cat >>conftest.$ac_ext <<_ACEOF
5243 /* end confdefs.h.  */
5244 #include "ppl_c.h"
5245 int
5246 main ()
5247 {
5248
5249   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5250   choke me
5251   #endif
5252
5253   ;
5254   return 0;
5255 }
5256 _ACEOF
5257 rm -f conftest.$ac_objext
5258 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5259   (eval $ac_compile) 2>conftest.er1
5260   ac_status=$?
5261   grep -v '^ *+' conftest.er1 >conftest.err
5262   rm -f conftest.er1
5263   cat conftest.err >&5
5264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5265   (exit $ac_status); } &&
5266          { ac_try='test -z "$ac_c_werror_flag"
5267                          || test ! -s conftest.err'
5268   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5269   (eval $ac_try) 2>&5
5270   ac_status=$?
5271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5272   (exit $ac_status); }; } &&
5273          { ac_try='test -s conftest.$ac_objext'
5274   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5275   (eval $ac_try) 2>&5
5276   ac_status=$?
5277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5278   (exit $ac_status); }; }; then
5279   echo "$as_me:$LINENO: result: yes" >&5
5280 echo "${ECHO_T}yes" >&6
5281 else
5282   echo "$as_me: failed program was:" >&5
5283 sed 's/^/| /' conftest.$ac_ext >&5
5284
5285 echo "$as_me:$LINENO: result: no" >&5
5286 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5287 fi
5288 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5289   CFLAGS="$saved_CFLAGS"
5290 fi
5291
5292 # Flags needed for PPL
5293
5294
5295
5296
5297 # Check for CLOOG
5298 clooglibs=" -lcloog "
5299 clooginc=" -DCLOOG_PPL_BACKEND "
5300
5301
5302 # Check whether --with-cloog or --without-cloog was given.
5303 if test "${with_cloog+set}" = set; then
5304   withval="$with_cloog"
5305
5306 else
5307   with_cloog=no
5308 fi;
5309
5310 # Check whether --with-cloog_include or --without-cloog_include was given.
5311 if test "${with_cloog_include+set}" = set; then
5312   withval="$with_cloog_include"
5313
5314 fi;
5315
5316 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5317 if test "${with_cloog_lib+set}" = set; then
5318   withval="$with_cloog_lib"
5319
5320 fi;
5321
5322 case $with_cloog in
5323   no)
5324     clooglibs=
5325     clooginc=
5326     ;;
5327   *)
5328     clooglibs="-L$with_cloog/lib -lcloog"
5329     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5330     LIBS="$clooglibs $LIBS"
5331     ;;
5332 esac
5333 if test "x$with_cloog_include" != x; then
5334   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5335 fi
5336 if test "x$with_cloog_lib" != x; then
5337   clooglibs="-L$with_cloog_lib -lcloog"
5338   LIBS="$clooglibs $LIBS"
5339 fi
5340 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5341   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5342   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5343   LIBS="$clooglibs $LIBS"
5344 fi
5345
5346 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5347 if test "${enable_cloog_version_check+set}" = set; then
5348   enableval="$enable_cloog_version_check"
5349   ENABLE_CLOOG_CHECK=$enableval
5350 else
5351   ENABLE_CLOOG_CHECK=yes
5352 fi;
5353
5354 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5355   saved_CFLAGS="$CFLAGS"
5356   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5357   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5358 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5359   cat >conftest.$ac_ext <<_ACEOF
5360 /* confdefs.h.  */
5361 _ACEOF
5362 cat confdefs.h >>conftest.$ac_ext
5363 cat >>conftest.$ac_ext <<_ACEOF
5364 /* end confdefs.h.  */
5365 #include "cloog/cloog.h"
5366 int
5367 main ()
5368 {
5369
5370   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5371   choke me
5372   #endif
5373
5374   ;
5375   return 0;
5376 }
5377 _ACEOF
5378 rm -f conftest.$ac_objext
5379 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5380   (eval $ac_compile) 2>conftest.er1
5381   ac_status=$?
5382   grep -v '^ *+' conftest.er1 >conftest.err
5383   rm -f conftest.er1
5384   cat conftest.err >&5
5385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5386   (exit $ac_status); } &&
5387          { ac_try='test -z "$ac_c_werror_flag"
5388                          || test ! -s conftest.err'
5389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5390   (eval $ac_try) 2>&5
5391   ac_status=$?
5392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5393   (exit $ac_status); }; } &&
5394          { ac_try='test -s conftest.$ac_objext'
5395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5396   (eval $ac_try) 2>&5
5397   ac_status=$?
5398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5399   (exit $ac_status); }; }; then
5400   echo "$as_me:$LINENO: result: yes" >&5
5401 echo "${ECHO_T}yes" >&6
5402 else
5403   echo "$as_me: failed program was:" >&5
5404 sed 's/^/| /' conftest.$ac_ext >&5
5405
5406 echo "$as_me:$LINENO: result: no" >&5
5407 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5408 fi
5409 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5410   CFLAGS="$saved_CFLAGS"
5411 fi
5412
5413 # Flags needed for CLOOG
5414
5415
5416
5417
5418 # By default, C is the only stage 1 language.
5419 stage1_languages=,c,
5420
5421 # Target libraries that we bootstrap.
5422 bootstrap_target_libs=,target-libgcc,
5423
5424 # Figure out what language subdirectories are present.
5425 # Look if the user specified --enable-languages="..."; if not, use
5426 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5427 # go away some day.
5428 # NB:  embedded tabs in this IF block -- do not untabify
5429 if test -d ${srcdir}/gcc; then
5430   if test x"${enable_languages+set}" != xset; then
5431     if test x"${LANGUAGES+set}" = xset; then
5432       enable_languages="${LANGUAGES}"
5433         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5434     else
5435       enable_languages=all
5436     fi
5437   else
5438     if test x"${enable_languages}" = x ||
5439        test x"${enable_languages}" = xyes;
5440        then
5441       echo configure.in: --enable-languages needs at least one language argument 1>&2
5442       exit 1
5443     fi
5444   fi
5445   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5446
5447   # 'f95' is the old name for the 'fortran' language. We issue a warning
5448   # and make the substitution.
5449   case ,${enable_languages}, in
5450     *,f95,*)
5451       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5452       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5453       ;;
5454   esac
5455
5456   # First scan to see if an enabled language requires some other language.
5457   # We assume that a given config-lang.in will list all the language
5458   # front ends it requires, even if some are required indirectly.
5459   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5460     case ${lang_frag} in
5461       ..) ;;
5462       # The odd quoting in the next line works around
5463       # an apparent bug in bash 1.12 on linux.
5464       ${srcdir}/gcc/[*]/config-lang.in) ;;
5465       *)
5466         # From the config-lang.in, get $language, $lang_requires
5467         language=
5468         lang_requires=
5469         . ${lang_frag}
5470         for other in ${lang_requires} ; do
5471           case ,${enable_languages}, in
5472             *,$other,*) ;;
5473             *,all,*) ;;
5474             *,$language,*)
5475               echo " \`$other' language required by \`$language'; enabling" 1>&2
5476               enable_languages="${enable_languages},${other}"
5477               ;;
5478           esac
5479         done
5480         ;;
5481     esac
5482   done
5483
5484   new_enable_languages=,c,
5485   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5486   potential_languages=,c,
5487
5488   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5489     case ${lang_frag} in
5490       ..) ;;
5491       # The odd quoting in the next line works around
5492       # an apparent bug in bash 1.12 on linux.
5493       ${srcdir}/gcc/[*]/config-lang.in) ;;
5494       *)
5495         # From the config-lang.in, get $language, $target_libs,
5496         # $lang_dirs, $boot_language, and $build_by_default
5497         language=
5498         target_libs=
5499         lang_dirs=
5500         subdir_requires=
5501         boot_language=no
5502         build_by_default=yes
5503         . ${lang_frag}
5504         if test x${language} = x; then
5505           echo "${lang_frag} doesn't set \$language." 1>&2
5506           exit 1
5507         fi
5508
5509         if test "$language" = "c++" -a "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5510           boot_language=yes
5511         fi
5512
5513         case ,${enable_languages}, in
5514           *,${language},*)
5515             # Language was explicitly selected; include it.
5516             add_this_lang=yes
5517             ;;
5518           *,all,*)
5519             # 'all' was selected, select it if it is a default language
5520             add_this_lang=${build_by_default}
5521             ;;
5522           *)
5523             add_this_lang=no
5524             ;;
5525         esac
5526
5527         # Disable languages that need other directories if these aren't available.
5528         for i in $subdir_requires; do
5529           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5530           case ,${enable_languages}, in
5531             *,${language},*)
5532               # Specifically requested language; tell them.
5533               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5534 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5535    { (exit 1); exit 1; }; }
5536               ;;
5537             *)
5538               # Silently disable.
5539               add_this_lang=unsupported
5540               ;;
5541           esac
5542         done
5543
5544         # Disable Ada if no preexisting GNAT is available.
5545         case ,${enable_languages},:${language}:${have_gnat} in
5546           *,${language},*:ada:no)
5547             # Specifically requested language; tell them.
5548             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5549 echo "$as_me: error: GNAT is required to build $language" >&2;}
5550    { (exit 1); exit 1; }; }
5551             ;;
5552           *:ada:no)
5553             # Silently disable.
5554             add_this_lang=unsupported
5555             ;;
5556         esac
5557
5558         # Disable a language that is unsupported by the target.
5559         case " $unsupported_languages " in
5560           *" $language "*)
5561             add_this_lang=unsupported
5562             ;;
5563         esac
5564
5565         case $add_this_lang in
5566           unsupported)
5567             # Remove language-dependent dirs.
5568             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5569             ;;
5570           no)
5571             # Remove language-dependent dirs; still show language as supported.
5572             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5573             potential_languages="${potential_languages}${language},"
5574             ;;
5575           yes)
5576             new_enable_languages="${new_enable_languages}${language},"
5577             potential_languages="${potential_languages}${language},"
5578             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5579             case ${boot_language} in
5580               yes)
5581                 # Add to (comma-separated) list of stage 1 languages.
5582                 stage1_languages="${stage1_languages}${language},"
5583                 # We need to bootstrap any supporting libraries.
5584                 bootstrap_target_libs="${bootstrap_target_libs}${target_libs},"
5585                 ;;
5586             esac
5587             ;;
5588         esac
5589         ;;
5590     esac
5591   done
5592
5593   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5594 if test "${enable_stage1_languages+set}" = set; then
5595   enableval="$enable_stage1_languages"
5596   case ,${enable_stage1_languages}, in
5597     ,no,|,,)
5598       # Set it to something that will have no effect in the loop below
5599       enable_stage1_languages=c ;;
5600     ,yes,)
5601       enable_stage1_languages=`echo $new_enable_languages | \
5602         sed -e "s/^,//" -e "s/,$//" ` ;;
5603     *,all,*)
5604       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5605         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5606   esac
5607
5608   # Add "good" languages from enable_stage1_languages to stage1_languages,
5609   # while "bad" languages go in missing_languages.  Leave no duplicates.
5610   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5611     case $potential_languages in
5612       *,$i,*)
5613         case $stage1_languages in
5614           *,$i,*) ;;
5615           *) stage1_languages="$stage1_languages$i," ;;
5616         esac ;;
5617       *)
5618         case $missing_languages in
5619           *,$i,*) ;;
5620           *) missing_languages="$missing_languages$i," ;;
5621         esac ;;
5622      esac
5623   done
5624 fi;
5625
5626   # Remove leading/trailing commas that were added for simplicity
5627   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5628   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5629   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5630   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5631
5632   if test "x$missing_languages" != x; then
5633     { { echo "$as_me:$LINENO: error:
5634 The following requested languages could not be built: ${missing_languages}
5635 Supported languages are: ${potential_languages}" >&5
5636 echo "$as_me: error:
5637 The following requested languages could not be built: ${missing_languages}
5638 Supported languages are: ${potential_languages}" >&2;}
5639    { (exit 1); exit 1; }; }
5640   fi
5641   if test "x$new_enable_languages" != "x$enable_languages"; then
5642     echo The following languages will be built: ${new_enable_languages}
5643     enable_languages="$new_enable_languages"
5644   fi
5645
5646
5647   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5648 fi
5649
5650 # Handle --disable-<component> generically.
5651 for dir in $configdirs $build_configdirs $target_configdirs ; do
5652   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5653   varname=`echo $dirname | sed -e s/+/_/g`
5654   if eval test x\${enable_${varname}} "=" xno ; then
5655     noconfigdirs="$noconfigdirs $dir"
5656   fi
5657 done
5658
5659 # Check for Boehm's garbage collector
5660 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5661 if test "${enable_objc_gc+set}" = set; then
5662   enableval="$enable_objc_gc"
5663   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5664   *,objc,*:*:yes:*target-boehm-gc*)
5665     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5666 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5667    { (exit 1); exit 1; }; }
5668     ;;
5669 esac
5670 fi;
5671
5672 # Make sure we only build Boehm's garbage collector if required.
5673 case ,${enable_languages},:${enable_objc_gc} in
5674   *,objc,*:yes)
5675     # Keep target-boehm-gc if requested for Objective-C.
5676     ;;
5677   *)
5678     # Otherwise remove target-boehm-gc depending on target-libjava.
5679     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5680       noconfigdirs="$noconfigdirs target-boehm-gc"
5681     fi
5682     ;;
5683 esac
5684
5685 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5686 # $build_configdirs and $target_configdirs.
5687 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5688
5689 notsupp=""
5690 for dir in . $skipdirs $noconfigdirs ; do
5691   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5692   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5693     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5694     if test -r $srcdir/$dirname/configure ; then
5695       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5696         true
5697       else
5698         notsupp="$notsupp $dir"
5699       fi
5700     fi
5701   fi
5702   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5703     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5704     if test -r $srcdir/$dirname/configure ; then
5705       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5706         true
5707       else
5708         notsupp="$notsupp $dir"
5709       fi
5710     fi
5711   fi
5712   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5713     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5714     if test -r $srcdir/$dirname/configure ; then
5715       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5716         true
5717       else
5718         notsupp="$notsupp $dir"
5719       fi
5720     fi
5721   fi
5722 done
5723
5724 # Sometimes the tools are distributed with libiberty but with no other
5725 # libraries.  In that case, we don't want to build target-libiberty.
5726 # Don't let libgcc imply libiberty either.
5727 if test -n "${target_configdirs}" ; then
5728   libgcc=
5729   others=
5730   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5731     if test "$i" = "libgcc"; then
5732       libgcc=target-libgcc
5733     elif test "$i" != "libiberty" ; then
5734       if test -r $srcdir/$i/configure ; then
5735         others=yes;
5736         break;
5737       fi
5738     fi
5739   done
5740   if test -z "${others}" ; then
5741     target_configdirs=$libgcc
5742   fi
5743 fi
5744
5745 # Quietly strip out all directories which aren't configurable in this tree.
5746 # This relies on all configurable subdirectories being autoconfiscated, which
5747 # is now the case.
5748 build_configdirs_all="$build_configdirs"
5749 build_configdirs=
5750 for i in ${build_configdirs_all} ; do
5751   j=`echo $i | sed -e s/build-//g`
5752   if test -f ${srcdir}/$j/configure ; then
5753     build_configdirs="${build_configdirs} $i"
5754   fi
5755 done
5756
5757 configdirs_all="$configdirs"
5758 configdirs=
5759 for i in ${configdirs_all} ; do
5760   if test -f ${srcdir}/$i/configure ; then
5761     configdirs="${configdirs} $i"
5762   fi
5763 done
5764
5765 target_configdirs_all="$target_configdirs"
5766 target_configdirs=
5767 for i in ${target_configdirs_all} ; do
5768   j=`echo $i | sed -e s/target-//g`
5769   if test -f ${srcdir}/$j/configure ; then
5770     target_configdirs="${target_configdirs} $i"
5771   fi
5772 done
5773
5774 # Produce a warning message for the subdirs we can't configure.
5775 # This isn't especially interesting in the Cygnus tree, but in the individual
5776 # FSF releases, it's important to let people know when their machine isn't
5777 # supported by the one or two programs in a package.
5778
5779 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5780   # If $appdirs is non-empty, at least one of those directories must still
5781   # be configured, or we error out.  (E.g., if the gas release supports a
5782   # specified target in some subdirs but not the gas subdir, we shouldn't
5783   # pretend that all is well.)
5784   if test -n "$appdirs" ; then
5785     for dir in $appdirs ; do
5786       if test -r $dir/Makefile.in ; then
5787         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5788           appdirs=""
5789           break
5790         fi
5791         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5792           appdirs=""
5793           break
5794         fi
5795       fi
5796     done
5797     if test -n "$appdirs" ; then
5798       echo "*** This configuration is not supported by this package." 1>&2
5799       exit 1
5800     fi
5801   fi
5802   # Okay, some application will build, or we don't care to check.  Still
5803   # notify of subdirs not getting built.
5804   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5805   echo "    ${notsupp}" 1>&2
5806   echo "    (Any other directories should still work fine.)" 1>&2
5807 fi
5808
5809 case "$host" in
5810   *msdosdjgpp*)
5811     enable_gdbtk=no ;;
5812 esac
5813
5814 # To find our prefix, in gcc_cv_tool_prefix.
5815
5816 # The user is always right.
5817 if test "${PATH_SEPARATOR+set}" != set; then
5818   echo "#! /bin/sh" >conf$$.sh
5819   echo  "exit 0"   >>conf$$.sh
5820   chmod +x conf$$.sh
5821   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5822     PATH_SEPARATOR=';'
5823   else
5824     PATH_SEPARATOR=:
5825   fi
5826   rm -f conf$$.sh
5827 fi
5828
5829
5830
5831 if test "x$exec_prefix" = xNONE; then
5832         if test "x$prefix" = xNONE; then
5833                 gcc_cv_tool_prefix=$ac_default_prefix
5834         else
5835                 gcc_cv_tool_prefix=$prefix
5836         fi
5837 else
5838         gcc_cv_tool_prefix=$exec_prefix
5839 fi
5840
5841 # If there is no compiler in the tree, use the PATH only.  In any
5842 # case, if there is no compiler in the tree nobody should use
5843 # AS_FOR_TARGET and LD_FOR_TARGET.
5844 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5845     gcc_version=`cat $srcdir/gcc/BASE-VER`
5846     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5847     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5848     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5849     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5850     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5851     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5852 else
5853     gcc_cv_tool_dirs=
5854 fi
5855
5856 if test x$build = x$target && test -n "$md_exec_prefix"; then
5857         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5858 fi
5859
5860
5861
5862 copy_dirs=
5863
5864
5865 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5866 if test "${with_build_sysroot+set}" = set; then
5867   withval="$with_build_sysroot"
5868   if test x"$withval" != x ; then
5869      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5870    fi
5871 else
5872   SYSROOT_CFLAGS_FOR_TARGET=
5873 fi;
5874
5875
5876
5877 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5878 if test "${with_debug_prefix_map+set}" = set; then
5879   withval="$with_debug_prefix_map"
5880   if test x"$withval" != x; then
5881      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5882      for debug_map in $withval; do
5883        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5884      done
5885    fi
5886 else
5887   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5888 fi;
5889
5890
5891 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5892 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5893 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5894 # We want to ensure that TARGET libraries (which we know are built with
5895 # gcc) are built with "-O2 -g", so include those options when setting
5896 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5897 if test "x$CFLAGS_FOR_TARGET" = x; then
5898   CFLAGS_FOR_TARGET=$CFLAGS
5899   case " $CFLAGS " in
5900     *" -O2 "*) ;;
5901     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5902   esac
5903   case " $CFLAGS " in
5904     *" -g "* | *" -g3 "*) ;;
5905     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5906   esac
5907 fi
5908
5909
5910 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5911   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5912   case " $CXXFLAGS " in
5913     *" -O2 "*) ;;
5914     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5915   esac
5916   case " $CXXFLAGS " in
5917     *" -g "* | *" -g3 "*) ;;
5918     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5919   esac
5920 fi
5921
5922
5923 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5924 # the named directory are copied to $(tooldir)/sys-include.
5925 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5926   if test x${is_cross_compiler} = xno ; then
5927     echo 1>&2 '***' --with-headers is only supported when cross compiling
5928     exit 1
5929   fi
5930   if test x"${with_headers}" != xyes ; then
5931     x=${gcc_cv_tool_prefix}
5932     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5933   fi
5934 fi
5935
5936 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5937 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5938 # are permitted.
5939 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5940   if test x${is_cross_compiler} = xno ; then
5941     echo 1>&2 '***' --with-libs is only supported when cross compiling
5942     exit 1
5943   fi
5944   if test x"${with_libs}" != xyes ; then
5945     # Copy the libraries in reverse order, so that files in the first named
5946     # library override files in subsequent libraries.
5947     x=${gcc_cv_tool_prefix}
5948     for l in ${with_libs}; do
5949       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5950     done
5951   fi
5952 fi
5953
5954 # Set with_gnu_as and with_gnu_ld as appropriate.
5955 #
5956 # This is done by determining whether or not the appropriate directory
5957 # is available, and by checking whether or not specific configurations
5958 # have requested that this magic not happen.
5959 #
5960 # The command line options always override the explicit settings in
5961 # configure.in, and the settings in configure.in override this magic.
5962 #
5963 # If the default for a toolchain is to use GNU as and ld, and you don't
5964 # want to do that, then you should use the --without-gnu-as and
5965 # --without-gnu-ld options for the configure script.
5966
5967 if test x${use_gnu_as} = x &&
5968    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5969   with_gnu_as=yes
5970   extra_host_args="$extra_host_args --with-gnu-as"
5971 fi
5972
5973 if test x${use_gnu_ld} = x &&
5974    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5975   with_gnu_ld=yes
5976   extra_host_args="$extra_host_args --with-gnu-ld"
5977 fi
5978
5979 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5980 # can detect this case.
5981
5982 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5983   with_newlib=yes
5984   extra_host_args="$extra_host_args --with-newlib"
5985 fi
5986
5987 # Handle ${copy_dirs}
5988 set fnord ${copy_dirs}
5989 shift
5990 while test $# != 0 ; do
5991   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5992     :
5993   else
5994     echo Copying $1 to $2
5995
5996     # Use the install script to create the directory and all required
5997     # parent directories.
5998     if test -d $2 ; then
5999       :
6000     else
6001       echo >config.temp
6002       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
6003     fi
6004
6005     # Copy the directory, assuming we have tar.
6006     # FIXME: Should we use B in the second tar?  Not all systems support it.
6007     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
6008
6009     # It is the responsibility of the user to correctly adjust all
6010     # symlinks.  If somebody can figure out how to handle them correctly
6011     # here, feel free to add the code.
6012
6013     echo $1 > $2/COPIED
6014   fi
6015   shift; shift
6016 done
6017
6018 # Determine a target-dependent exec_prefix that the installed
6019 # gcc will search in.  Keep this list sorted by triplet, with
6020 # the *-*-osname triplets last.
6021 md_exec_prefix=
6022 case "${target}" in
6023   alpha*-*-*vms*)
6024     md_exec_prefix=/gnu/lib/gcc-lib
6025     ;;
6026   i[34567]86-pc-msdosdjgpp*)
6027     md_exec_prefix=/dev/env/DJDIR/bin
6028     ;;
6029   i[34567]86-*-sco3.2v5*)
6030     if test $with_gnu_as = yes; then
6031       md_exec_prefix=/usr/gnu/bin
6032     else
6033       md_exec_prefix=/usr/ccs/bin/elf
6034     fi
6035     ;;
6036
6037   mn10300-*-* | \
6038   powerpc-*-chorusos* | \
6039   powerpc*-*-eabi* | \
6040   powerpc*-*-sysv* | \
6041   powerpc*-*-kaos* | \
6042   s390x-ibm-tpf*)
6043     md_exec_prefix=/usr/ccs/bin
6044     ;;
6045   sparc64-*-elf*)
6046     ;;
6047   v850*-*-*)
6048     md_exec_prefix=/usr/ccs/bin
6049     ;;
6050   xtensa*-*-elf*)
6051     ;;
6052
6053   *-*-beos* | \
6054   *-*-elf* | \
6055   *-*-hpux* | \
6056   *-*-netware* | \
6057   *-*-nto-qnx* | \
6058   *-*-rtems* | \
6059   *-*-solaris2* | \
6060   *-*-sysv[45]* | \
6061   *-*-vxworks* | \
6062   *-wrs-windiss)
6063     md_exec_prefix=/usr/ccs/bin
6064     ;;
6065 esac
6066
6067 extra_arflags_for_target=
6068 extra_nmflags_for_target=
6069 extra_ranlibflags_for_target=
6070 target_makefile_frag=/dev/null
6071 case "${target}" in
6072   mep*-*-*)
6073     target_makefile_frag="config/mt-mep"
6074     ;;
6075   spu-*-*)
6076     target_makefile_frag="config/mt-spu"
6077     ;;
6078   mips*-sde-elf*)
6079     target_makefile_frag="config/mt-sde"
6080     ;;
6081   mipsisa*-*-elfoabi*)
6082     target_makefile_frag="config/mt-mips-elfoabi"
6083     ;;
6084   mips*-*-*linux* | mips*-*-gnu*)
6085     target_makefile_frag="config/mt-mips-gnu"
6086     ;;
6087   *-*-netware*)
6088     target_makefile_frag="config/mt-netware"
6089     ;;
6090   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
6091     target_makefile_frag="config/mt-gnu"
6092     ;;
6093   *-*-aix4.[3456789]* | *-*-aix[56789].*)
6094     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
6095     # commands to handle both 32-bit and 64-bit objects.  These flags are
6096     # harmless if we're using GNU nm or ar.
6097     extra_arflags_for_target=" -X32_64"
6098     extra_nmflags_for_target=" -B -X32_64"
6099     ;;
6100   *-*-darwin*)
6101     # ranlib from Darwin requires the -c flag to look at common symbols.
6102     extra_ranlibflags_for_target=" -c"
6103     ;;
6104   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6105     target_makefile_frag="config/mt-wince"
6106     ;;
6107 esac
6108
6109 alphaieee_frag=/dev/null
6110 case $target in
6111   alpha*-*-*)
6112     # This just makes sure to use the -mieee option to build target libs.
6113     # This should probably be set individually by each library.
6114     alphaieee_frag="config/mt-alphaieee"
6115     ;;
6116 esac
6117
6118 # If --enable-target-optspace always use -Os instead of -O2 to build
6119 # the target libraries, similarly if it is not specified, use -Os
6120 # on selected platforms.
6121 ospace_frag=/dev/null
6122 case "${enable_target_optspace}:${target}" in
6123   yes:*)
6124     ospace_frag="config/mt-ospace"
6125     ;;
6126   :d30v-*)
6127     ospace_frag="config/mt-d30v"
6128     ;;
6129   :m32r-* | :d10v-* | :fr30-*)
6130     ospace_frag="config/mt-ospace"
6131     ;;
6132   no:* | :*)
6133     ;;
6134   *)
6135     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6136     ;;
6137 esac
6138
6139 # Default to using --with-stabs for certain targets.
6140 if test x${with_stabs} = x ; then
6141   case "${target}" in
6142   mips*-*-irix[56]*)
6143     ;;
6144   mips*-*-* | alpha*-*-osf*)
6145     with_stabs=yes;
6146     extra_host_args="${extra_host_args} --with-stabs"
6147     ;;
6148   esac
6149 fi
6150
6151 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6152 # them automatically.
6153 case "${host}" in
6154   hppa*64*-*-hpux11*)
6155     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6156     ;;
6157 esac
6158
6159 # Some systems (e.g., one of the i386-aix systems the gas testers are
6160 # using) don't handle "\$" correctly, so don't use it here.
6161 tooldir='${exec_prefix}'/${target_noncanonical}
6162 build_tooldir=${tooldir}
6163
6164 # Create a .gdbinit file which runs the one in srcdir
6165 # and tells GDB to look there for source files.
6166
6167 if test -r ${srcdir}/.gdbinit ; then
6168   case ${srcdir} in
6169     .) ;;
6170     *) cat > ./.gdbinit <<EOF
6171 # ${NO_EDIT}
6172 dir ${srcdir}
6173 dir .
6174 source ${srcdir}/.gdbinit
6175 EOF
6176     ;;
6177   esac
6178 fi
6179
6180 # Make sure that the compiler is able to generate an executable.  If it
6181 # can't, we are probably in trouble.  We don't care whether we can run the
6182 # executable--we might be using a cross compiler--we only care whether it
6183 # can be created.  At this point the main configure script has set CC.
6184 we_are_ok=no
6185 echo "int main () { return 0; }" > conftest.c
6186 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6187 if test $? = 0 ; then
6188   if test -s conftest || test -s conftest.exe ; then
6189     we_are_ok=yes
6190   fi
6191 fi
6192 case $we_are_ok in
6193   no)
6194     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6195     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6196     rm -f conftest*
6197     exit 1
6198     ;;
6199 esac
6200 rm -f conftest*
6201
6202 # The Solaris /usr/ucb/cc compiler does not appear to work.
6203 case "${host}" in
6204   sparc-sun-solaris2*)
6205       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6206       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6207           could_use=
6208           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6209           if test -d /opt/cygnus/bin ; then
6210               if test "$could_use" = "" ; then
6211                   could_use="/opt/cygnus/bin"
6212               else
6213                   could_use="$could_use or /opt/cygnus/bin"
6214               fi
6215           fi
6216         if test "$could_use" = "" ; then
6217             echo "Warning: compilation may fail because you're using"
6218             echo "/usr/ucb/cc.  You should change your PATH or CC "
6219             echo "variable and rerun configure."
6220         else
6221             echo "Warning: compilation may fail because you're using"
6222             echo "/usr/ucb/cc, when you should use the C compiler from"
6223             echo "$could_use.  You should change your"
6224             echo "PATH or CC variable and rerun configure."
6225         fi
6226       fi
6227   ;;
6228 esac
6229
6230 # Decide which environment variable is used to find dynamic libraries.
6231 case "${host}" in
6232   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6233   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6234   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6235   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6236 esac
6237
6238 # On systems where the dynamic library environment variable is PATH,
6239 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6240 # built executables to PATH.
6241 if test "$RPATH_ENVVAR" = PATH; then
6242   GCC_SHLIB_SUBDIR=/shlib
6243 else
6244   GCC_SHLIB_SUBDIR=
6245 fi
6246
6247 # Record target_configdirs and the configure arguments for target and
6248 # build configuration in Makefile.
6249 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6250 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6251
6252 # Determine whether gdb needs tk/tcl or not.
6253 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6254 # and in that case we want gdb to be built without tk.  Ugh!
6255 # In fact I believe gdb is the *only* package directly dependent on tk,
6256 # so we should be able to put the 'maybe's in unconditionally and
6257 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6258 # 100% sure that that's safe though.
6259
6260 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6261 case "$enable_gdbtk" in
6262   no)
6263     GDB_TK="" ;;
6264   yes)
6265     GDB_TK="${gdb_tk}" ;;
6266   *)
6267     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6268     # distro.  Eventually someone will fix this and move Insight, nee
6269     # gdbtk to a separate directory.
6270     if test -d ${srcdir}/gdb/gdbtk ; then
6271       GDB_TK="${gdb_tk}"
6272     else
6273       GDB_TK=""
6274     fi
6275     ;;
6276 esac
6277 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6278 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6279
6280 # Strip out unwanted targets.
6281
6282 # While at that, we remove Makefiles if we were started for recursive
6283 # configuration, so that the top-level Makefile reconfigures them,
6284 # like we used to do when configure itself was recursive.
6285
6286 # Loop over modules.  $extrasub must be used with care, limiting as
6287 # much as possible the usage of range addresses.  That's because autoconf
6288 # splits the sed script to overcome limits in the number of commands,
6289 # and relying on carefully-timed sed passes may turn out to be very hard
6290 # to maintain later.  In this particular case, you just have to be careful
6291 # not to nest @if/@endif pairs, because configure will not warn you at all.
6292
6293 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6294 if test "${enable_bootstrap+set}" = set; then
6295   enableval="$enable_bootstrap"
6296
6297 else
6298   enable_bootstrap=default
6299 fi;
6300
6301 # Issue errors and warnings for invalid/strange bootstrap combinations.
6302 case "$configdirs" in
6303   *gcc*) have_compiler=yes ;;
6304   *) have_compiler=no ;;
6305 esac
6306
6307 case "$have_compiler:$host:$target:$enable_bootstrap" in
6308   *:*:*:no) ;;
6309
6310   # Default behavior.  Enable bootstrap if we have a compiler
6311   # and we are in a native configuration.
6312   yes:$build:$build:default)
6313     enable_bootstrap=yes ;;
6314
6315   *:*:*:default)
6316     enable_bootstrap=no ;;
6317
6318   # We have a compiler and we are in a native configuration, bootstrap is ok
6319   yes:$build:$build:yes)
6320     ;;
6321
6322   # Other configurations, but we have a compiler.  Assume the user knows
6323   # what he's doing.
6324   yes:*:*:yes)
6325     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6326 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6327     ;;
6328
6329   # No compiler: if they passed --enable-bootstrap explicitly, fail
6330   no:*:*:yes)
6331     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6332 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6333    { (exit 1); exit 1; }; } ;;
6334
6335   # Fail if wrong command line
6336   *)
6337     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6338 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6339    { (exit 1); exit 1; }; }
6340     ;;
6341 esac
6342
6343 # Adjust the toplevel makefile according to whether bootstrap was selected.
6344 case "$enable_bootstrap" in
6345   yes)
6346     bootstrap_suffix=bootstrap ;;
6347   no)
6348     bootstrap_suffix=no-bootstrap ;;
6349 esac
6350
6351 for module in ${build_configdirs} ; do
6352   if test -z "${no_recursion}" \
6353      && test -f ${build_subdir}/${module}/Makefile; then
6354     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6355     rm -f ${build_subdir}/${module}/Makefile
6356   fi
6357   extrasub="$extrasub
6358 /^@if build-$module\$/d
6359 /^@endif build-$module\$/d
6360 /^@if build-$module-$bootstrap_suffix\$/d
6361 /^@endif build-$module-$bootstrap_suffix\$/d"
6362 done
6363 for module in ${configdirs} ; do
6364   if test -z "${no_recursion}"; then
6365     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6366       if test -f ${file}; then
6367         echo 1>&2 "*** removing ${file} to force reconfigure"
6368         rm -f ${file}
6369       fi
6370     done
6371   fi
6372   extrasub="$extrasub
6373 /^@if $module\$/d
6374 /^@endif $module\$/d
6375 /^@if $module-$bootstrap_suffix\$/d
6376 /^@endif $module-$bootstrap_suffix\$/d"
6377 done
6378 for module in ${target_configdirs} ; do
6379   if test -z "${no_recursion}" \
6380      && test -f ${target_subdir}/${module}/Makefile; then
6381     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6382     rm -f ${target_subdir}/${module}/Makefile
6383   fi
6384
6385   # We only bootstrap target libraries listed in bootstrap_target_libs.
6386   case $bootstrap_target_libs in
6387     *,target-$module,*) target_bootstrap_suffix=$bootstrap_suffix ;;
6388     *) target_bootstrap_suffix=no-bootstrap ;;
6389   esac
6390
6391   extrasub="$extrasub
6392 /^@if target-$module\$/d
6393 /^@endif target-$module\$/d
6394 /^@if target-$module-$target_bootstrap_suffix\$/d
6395 /^@endif target-$module-$target_bootstrap_suffix\$/d"
6396 done
6397
6398 extrasub="$extrasub
6399 /^@if /,/^@endif /d"
6400
6401 # Create the serialization dependencies.  This uses a temporary file.
6402
6403 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6404 if test "${enable_serial_configure+set}" = set; then
6405   enableval="$enable_serial_configure"
6406
6407 fi;
6408
6409 case ${enable_serial_configure} in
6410   yes)
6411     enable_serial_build_configure=yes
6412     enable_serial_host_configure=yes
6413     enable_serial_target_configure=yes
6414     ;;
6415 esac
6416
6417 # These force 'configure's to be done one at a time, to avoid problems
6418 # with contention over a shared config.cache.
6419 rm -f serdep.tmp
6420 echo '# serdep.tmp' > serdep.tmp
6421 olditem=
6422 test "x${enable_serial_build_configure}" = xyes &&
6423 for item in ${build_configdirs} ; do
6424   case ${olditem} in
6425     "") ;;
6426     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6427   esac
6428   olditem=${item}
6429 done
6430 olditem=
6431 test "x${enable_serial_host_configure}" = xyes &&
6432 for item in ${configdirs} ; do
6433   case ${olditem} in
6434     "") ;;
6435     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6436   esac
6437   olditem=${item}
6438 done
6439 olditem=
6440 test "x${enable_serial_target_configure}" = xyes &&
6441 for item in ${target_configdirs} ; do
6442   case ${olditem} in
6443     "") ;;
6444     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6445   esac
6446   olditem=${item}
6447 done
6448 serialization_dependencies=serdep.tmp
6449
6450
6451 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6452 # target, nonopt, and variable assignments.  These are the ones we
6453 # might not want to pass down to subconfigures.  Also strip
6454 # program-prefix, program-suffix, and program-transform-name, so that
6455 # we can pass down a consistent program-transform-name.
6456 baseargs=
6457 keep_next=no
6458 skip_next=no
6459 eval "set -- $ac_configure_args"
6460 for ac_arg
6461 do
6462   if test X"$skip_next" = X"yes"; then
6463     skip_next=no
6464     continue
6465   fi
6466   if test X"$keep_next" = X"yes"; then
6467     case $ac_arg in
6468       *\'*)
6469         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6470     esac
6471     baseargs="$baseargs '$ac_arg'"
6472     keep_next=no
6473     continue
6474   fi
6475
6476   # Handle separated arguments.  Based on the logic generated by
6477   # autoconf 2.59.
6478   case $ac_arg in
6479     *=* | --config-cache | -C | -disable-* | --disable-* \
6480       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6481       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6482       | -with-* | --with-* | -without-* | --without-* | --x)
6483       separate_arg=no
6484       ;;
6485     -*)
6486       separate_arg=yes
6487       ;;
6488     *)
6489       separate_arg=no
6490       ;;
6491   esac
6492
6493   case "$ac_arg" in
6494     --no*)
6495       continue
6496       ;;
6497     --c* | \
6498     --sr* | \
6499     --ho* | \
6500     --bu* | \
6501     --t* | \
6502     --program-* | \
6503     -cache_file* | \
6504     -srcdir* | \
6505     -host* | \
6506     -build* | \
6507     -target* | \
6508     -program-prefix* | \
6509     -program-suffix* | \
6510     -program-transform-name* )
6511       skip_next=$separate_arg
6512       continue
6513       ;;
6514     -*)
6515       # An option.  Add it.
6516       case $ac_arg in
6517         *\'*)
6518           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6519       esac
6520       baseargs="$baseargs '$ac_arg'"
6521       keep_next=$separate_arg
6522       ;;
6523     *)
6524       # Either a variable assignment, or a nonopt (triplet).  Don't
6525       # pass it down; let the Makefile handle this.
6526       continue
6527       ;;
6528   esac
6529 done
6530 # Remove the initial space we just introduced and, as these will be
6531 # expanded by make, quote '$'.
6532 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6533
6534 # Add in --program-transform-name, after --program-prefix and
6535 # --program-suffix have been applied to it.  Autoconf has already
6536 # doubled dollar signs and backslashes in program_transform_name; we want
6537 # the backslashes un-doubled, and then the entire thing wrapped in single
6538 # quotes, because this will be expanded first by make and then by the shell.
6539 # Also, because we want to override the logic in subdir configure scripts to
6540 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6541 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6542 ${program_transform_name}
6543 EOF_SED
6544 gcc_transform_name=`cat conftestsed.out`
6545 rm -f conftestsed.out
6546 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6547 if test "$silent" = yes; then
6548   baseargs="$baseargs --silent"
6549 fi
6550 baseargs="$baseargs --disable-option-checking"
6551
6552 # For the build-side libraries, we just need to pretend we're native,
6553 # and not use the same cache file.  Multilibs are neither needed nor
6554 # desired.
6555 build_configargs="--cache-file=../config.cache ${baseargs}"
6556
6557 # For host modules, accept cache file option, or specification as blank.
6558 case "${cache_file}" in
6559 "") # empty
6560   cache_file_option="" ;;
6561 /* | [A-Za-z]:[\\/]* ) # absolute path
6562   cache_file_option="--cache-file=${cache_file}" ;;
6563 *) # relative path
6564   cache_file_option="--cache-file=../${cache_file}" ;;
6565 esac
6566
6567 # Host dirs don't like to share a cache file either, horribly enough.
6568 # This seems to be due to autoconf 2.5x stupidity.
6569 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6570
6571 target_configargs=${baseargs}
6572
6573 # Passing a --with-cross-host argument lets the target libraries know
6574 # whether they are being built with a cross-compiler or being built
6575 # native.  However, it would be better to use other mechanisms to make the
6576 # sorts of decisions they want to make on this basis.  Please consider
6577 # this option to be deprecated.  FIXME.
6578 if test x${is_cross_compiler} = xyes ; then
6579   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6580 fi
6581
6582 # Default to --enable-multilib.
6583 if test x${enable_multilib} = x ; then
6584   target_configargs="--enable-multilib ${target_configargs}"
6585 fi
6586
6587 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6588 # changed from the earlier setting of with_newlib.
6589 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6590   target_configargs="--with-newlib ${target_configargs}"
6591 fi
6592
6593 # Different target subdirs use different values of certain variables
6594 # (notably CXX).  Worse, multilibs use *lots* of different values.
6595 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6596 # it doesn't automatically accept command-line overrides of them.
6597 # This means it's not safe for target subdirs to share a cache file,
6598 # which is disgusting, but there you have it.  Hopefully this can be
6599 # fixed in future.  It's still worthwhile to use a cache file for each
6600 # directory.  I think.
6601
6602 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6603 # We need to pass --target, as newer autoconf's requires consistency
6604 # for target_alias and gcc doesn't manage it consistently.
6605 target_configargs="--cache-file=./config.cache ${target_configargs}"
6606
6607 FLAGS_FOR_TARGET=
6608 case " $target_configdirs " in
6609  *" newlib "*)
6610   case " $target_configargs " in
6611   *" --with-newlib "*)
6612    case "$target" in
6613    *-cygwin*)
6614      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' ;;
6615    esac
6616
6617    # If we're not building GCC, don't discard standard headers.
6618    if test -d ${srcdir}/gcc; then
6619      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6620
6621      if test "${build}" != "${host}"; then
6622        # On Canadian crosses, CC_FOR_TARGET will have already been set
6623        # by `configure', so we won't have an opportunity to add -Bgcc/
6624        # to it.  This is right: we don't want to search that directory
6625        # for binaries, but we want the header files in there, so add
6626        # them explicitly.
6627        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6628
6629        # Someone might think of using the pre-installed headers on
6630        # Canadian crosses, in case the installed compiler is not fully
6631        # compatible with the compiler being built.  In this case, it
6632        # would be better to flag an error than risking having
6633        # incompatible object files being constructed.  We can't
6634        # guarantee that an error will be flagged, but let's hope the
6635        # compiler will do it, when presented with incompatible header
6636        # files.
6637      fi
6638    fi
6639
6640    case "${target}-${is_cross_compiler}" in
6641    i[3456789]86-*-linux*-no)
6642       # Here host == target, so we don't need to build gcc,
6643       # so we don't want to discard standard headers.
6644       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6645       ;;
6646    *)
6647       # If we're building newlib, use its generic headers last, but search
6648       # for any libc-related directories first (so make it the last -B
6649       # switch).
6650       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6651
6652       # If we're building libgloss, find the startup file, simulator library
6653       # and linker script.
6654       case " $target_configdirs " in
6655         *" libgloss "*)
6656         # Look for startup file, simulator library and maybe linker script.
6657         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6658         # Look for libnosys.a in case the target needs it.
6659         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6660         # Most targets have the linker script in the source directory.
6661         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6662         ;;
6663       esac
6664       ;;
6665    esac
6666    ;;
6667   esac
6668   ;;
6669 esac
6670 case "$target" in
6671 *-mingw*)
6672   # Can't be handled as Cygwin above since Mingw does not use newlib.
6673   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' ;;
6674 esac
6675
6676 # Allow the user to override the flags for
6677 # our build compiler if desired.
6678 if test x"${build}" = x"${host}" ; then
6679   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6680   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6681   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6682 fi
6683
6684 # On Canadian crosses, we'll be searching the right directories for
6685 # the previously-installed cross compiler, so don't bother to add
6686 # flags for directories within the install tree of the compiler
6687 # being built; programs in there won't even run.
6688 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6689   # Search for pre-installed headers if nothing else fits.
6690   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6691 fi
6692
6693 if test "x${use_gnu_ld}" = x &&
6694    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6695   # Arrange for us to find uninstalled linker scripts.
6696   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6697 fi
6698
6699 # Search for other target-specific linker scripts and such.
6700 case "${target}" in
6701   mep*)
6702     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6703     ;;
6704 esac
6705
6706 # Makefile fragments.
6707 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6708 do
6709   eval fragval=\$$frag
6710   if test $fragval != /dev/null; then
6711     eval $frag=${srcdir}/$fragval
6712   fi
6713 done
6714
6715
6716
6717
6718
6719 # Miscellanea: directories, flags, etc.
6720
6721
6722
6723
6724
6725
6726
6727
6728 # Build module lists & subconfigure args.
6729
6730
6731
6732 # Host module lists & subconfigure args.
6733
6734
6735
6736 # Target module lists & subconfigure args.
6737
6738
6739
6740 # Build tools.
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752
6753
6754
6755
6756
6757
6758 # Generate default definitions for YACC, M4, LEX and other programs that run
6759 # on the build machine.  These are used if the Makefile can't locate these
6760 # programs in objdir.
6761 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6762
6763 for ac_prog in 'bison -y' byacc yacc
6764 do
6765   # Extract the first word of "$ac_prog", so it can be a program name with args.
6766 set dummy $ac_prog; ac_word=$2
6767 echo "$as_me:$LINENO: checking for $ac_word" >&5
6768 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6769 if test "${ac_cv_prog_YACC+set}" = set; then
6770   echo $ECHO_N "(cached) $ECHO_C" >&6
6771 else
6772   if test -n "$YACC"; then
6773   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6774 else
6775 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6776 for as_dir in $PATH
6777 do
6778   IFS=$as_save_IFS
6779   test -z "$as_dir" && as_dir=.
6780   for ac_exec_ext in '' $ac_executable_extensions; do
6781   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6782     ac_cv_prog_YACC="$ac_prog"
6783     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6784     break 2
6785   fi
6786 done
6787 done
6788
6789 fi
6790 fi
6791 YACC=$ac_cv_prog_YACC
6792 if test -n "$YACC"; then
6793   echo "$as_me:$LINENO: result: $YACC" >&5
6794 echo "${ECHO_T}$YACC" >&6
6795 else
6796   echo "$as_me:$LINENO: result: no" >&5
6797 echo "${ECHO_T}no" >&6
6798 fi
6799
6800   test -n "$YACC" && break
6801 done
6802 test -n "$YACC" || YACC="$MISSING bison -y"
6803
6804 case " $build_configdirs " in
6805   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6806   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6807 esac
6808
6809 for ac_prog in bison
6810 do
6811   # Extract the first word of "$ac_prog", so it can be a program name with args.
6812 set dummy $ac_prog; ac_word=$2
6813 echo "$as_me:$LINENO: checking for $ac_word" >&5
6814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6815 if test "${ac_cv_prog_BISON+set}" = set; then
6816   echo $ECHO_N "(cached) $ECHO_C" >&6
6817 else
6818   if test -n "$BISON"; then
6819   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6820 else
6821 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6822 for as_dir in $PATH
6823 do
6824   IFS=$as_save_IFS
6825   test -z "$as_dir" && as_dir=.
6826   for ac_exec_ext in '' $ac_executable_extensions; do
6827   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6828     ac_cv_prog_BISON="$ac_prog"
6829     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6830     break 2
6831   fi
6832 done
6833 done
6834
6835 fi
6836 fi
6837 BISON=$ac_cv_prog_BISON
6838 if test -n "$BISON"; then
6839   echo "$as_me:$LINENO: result: $BISON" >&5
6840 echo "${ECHO_T}$BISON" >&6
6841 else
6842   echo "$as_me:$LINENO: result: no" >&5
6843 echo "${ECHO_T}no" >&6
6844 fi
6845
6846   test -n "$BISON" && break
6847 done
6848 test -n "$BISON" || BISON="$MISSING bison"
6849
6850 case " $build_configdirs " in
6851   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6852 esac
6853
6854 for ac_prog in gm4 gnum4 m4
6855 do
6856   # Extract the first word of "$ac_prog", so it can be a program name with args.
6857 set dummy $ac_prog; ac_word=$2
6858 echo "$as_me:$LINENO: checking for $ac_word" >&5
6859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6860 if test "${ac_cv_prog_M4+set}" = set; then
6861   echo $ECHO_N "(cached) $ECHO_C" >&6
6862 else
6863   if test -n "$M4"; then
6864   ac_cv_prog_M4="$M4" # Let the user override the test.
6865 else
6866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6867 for as_dir in $PATH
6868 do
6869   IFS=$as_save_IFS
6870   test -z "$as_dir" && as_dir=.
6871   for ac_exec_ext in '' $ac_executable_extensions; do
6872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6873     ac_cv_prog_M4="$ac_prog"
6874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6875     break 2
6876   fi
6877 done
6878 done
6879
6880 fi
6881 fi
6882 M4=$ac_cv_prog_M4
6883 if test -n "$M4"; then
6884   echo "$as_me:$LINENO: result: $M4" >&5
6885 echo "${ECHO_T}$M4" >&6
6886 else
6887   echo "$as_me:$LINENO: result: no" >&5
6888 echo "${ECHO_T}no" >&6
6889 fi
6890
6891   test -n "$M4" && break
6892 done
6893 test -n "$M4" || M4="$MISSING m4"
6894
6895 case " $build_configdirs " in
6896   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6897 esac
6898
6899 for ac_prog in flex lex
6900 do
6901   # Extract the first word of "$ac_prog", so it can be a program name with args.
6902 set dummy $ac_prog; ac_word=$2
6903 echo "$as_me:$LINENO: checking for $ac_word" >&5
6904 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6905 if test "${ac_cv_prog_LEX+set}" = set; then
6906   echo $ECHO_N "(cached) $ECHO_C" >&6
6907 else
6908   if test -n "$LEX"; then
6909   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6910 else
6911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6912 for as_dir in $PATH
6913 do
6914   IFS=$as_save_IFS
6915   test -z "$as_dir" && as_dir=.
6916   for ac_exec_ext in '' $ac_executable_extensions; do
6917   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6918     ac_cv_prog_LEX="$ac_prog"
6919     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6920     break 2
6921   fi
6922 done
6923 done
6924
6925 fi
6926 fi
6927 LEX=$ac_cv_prog_LEX
6928 if test -n "$LEX"; then
6929   echo "$as_me:$LINENO: result: $LEX" >&5
6930 echo "${ECHO_T}$LEX" >&6
6931 else
6932   echo "$as_me:$LINENO: result: no" >&5
6933 echo "${ECHO_T}no" >&6
6934 fi
6935
6936   test -n "$LEX" && break
6937 done
6938 test -n "$LEX" || LEX="$MISSING flex"
6939
6940 case " $build_configdirs " in
6941   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6942   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6943 esac
6944
6945 for ac_prog in flex
6946 do
6947   # Extract the first word of "$ac_prog", so it can be a program name with args.
6948 set dummy $ac_prog; ac_word=$2
6949 echo "$as_me:$LINENO: checking for $ac_word" >&5
6950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6951 if test "${ac_cv_prog_FLEX+set}" = set; then
6952   echo $ECHO_N "(cached) $ECHO_C" >&6
6953 else
6954   if test -n "$FLEX"; then
6955   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6956 else
6957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6958 for as_dir in $PATH
6959 do
6960   IFS=$as_save_IFS
6961   test -z "$as_dir" && as_dir=.
6962   for ac_exec_ext in '' $ac_executable_extensions; do
6963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6964     ac_cv_prog_FLEX="$ac_prog"
6965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6966     break 2
6967   fi
6968 done
6969 done
6970
6971 fi
6972 fi
6973 FLEX=$ac_cv_prog_FLEX
6974 if test -n "$FLEX"; then
6975   echo "$as_me:$LINENO: result: $FLEX" >&5
6976 echo "${ECHO_T}$FLEX" >&6
6977 else
6978   echo "$as_me:$LINENO: result: no" >&5
6979 echo "${ECHO_T}no" >&6
6980 fi
6981
6982   test -n "$FLEX" && break
6983 done
6984 test -n "$FLEX" || FLEX="$MISSING flex"
6985
6986 case " $build_configdirs " in
6987   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6988 esac
6989
6990 for ac_prog in makeinfo
6991 do
6992   # Extract the first word of "$ac_prog", so it can be a program name with args.
6993 set dummy $ac_prog; ac_word=$2
6994 echo "$as_me:$LINENO: checking for $ac_word" >&5
6995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6996 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6997   echo $ECHO_N "(cached) $ECHO_C" >&6
6998 else
6999   if test -n "$MAKEINFO"; then
7000   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
7001 else
7002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7003 for as_dir in $PATH
7004 do
7005   IFS=$as_save_IFS
7006   test -z "$as_dir" && as_dir=.
7007   for ac_exec_ext in '' $ac_executable_extensions; do
7008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7009     ac_cv_prog_MAKEINFO="$ac_prog"
7010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7011     break 2
7012   fi
7013 done
7014 done
7015
7016 fi
7017 fi
7018 MAKEINFO=$ac_cv_prog_MAKEINFO
7019 if test -n "$MAKEINFO"; then
7020   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
7021 echo "${ECHO_T}$MAKEINFO" >&6
7022 else
7023   echo "$as_me:$LINENO: result: no" >&5
7024 echo "${ECHO_T}no" >&6
7025 fi
7026
7027   test -n "$MAKEINFO" && break
7028 done
7029 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
7030
7031 case " $build_configdirs " in
7032   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
7033   *)
7034
7035     # For an installed makeinfo, we require it to be from texinfo 4.7 or
7036     # higher, else we use the "missing" dummy.
7037     if ${MAKEINFO} --version \
7038        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
7039       :
7040     else
7041       MAKEINFO="$MISSING makeinfo"
7042     fi
7043     ;;
7044
7045 esac
7046
7047 # FIXME: expect and dejagnu may become build tools?
7048
7049 for ac_prog in expect
7050 do
7051   # Extract the first word of "$ac_prog", so it can be a program name with args.
7052 set dummy $ac_prog; ac_word=$2
7053 echo "$as_me:$LINENO: checking for $ac_word" >&5
7054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7055 if test "${ac_cv_prog_EXPECT+set}" = set; then
7056   echo $ECHO_N "(cached) $ECHO_C" >&6
7057 else
7058   if test -n "$EXPECT"; then
7059   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
7060 else
7061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7062 for as_dir in $PATH
7063 do
7064   IFS=$as_save_IFS
7065   test -z "$as_dir" && as_dir=.
7066   for ac_exec_ext in '' $ac_executable_extensions; do
7067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7068     ac_cv_prog_EXPECT="$ac_prog"
7069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7070     break 2
7071   fi
7072 done
7073 done
7074
7075 fi
7076 fi
7077 EXPECT=$ac_cv_prog_EXPECT
7078 if test -n "$EXPECT"; then
7079   echo "$as_me:$LINENO: result: $EXPECT" >&5
7080 echo "${ECHO_T}$EXPECT" >&6
7081 else
7082   echo "$as_me:$LINENO: result: no" >&5
7083 echo "${ECHO_T}no" >&6
7084 fi
7085
7086   test -n "$EXPECT" && break
7087 done
7088 test -n "$EXPECT" || EXPECT="expect"
7089
7090 case " $configdirs " in
7091   *" expect "*)
7092     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
7093     ;;
7094 esac
7095
7096 for ac_prog in runtest
7097 do
7098   # Extract the first word of "$ac_prog", so it can be a program name with args.
7099 set dummy $ac_prog; ac_word=$2
7100 echo "$as_me:$LINENO: checking for $ac_word" >&5
7101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7102 if test "${ac_cv_prog_RUNTEST+set}" = set; then
7103   echo $ECHO_N "(cached) $ECHO_C" >&6
7104 else
7105   if test -n "$RUNTEST"; then
7106   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
7107 else
7108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7109 for as_dir in $PATH
7110 do
7111   IFS=$as_save_IFS
7112   test -z "$as_dir" && as_dir=.
7113   for ac_exec_ext in '' $ac_executable_extensions; do
7114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7115     ac_cv_prog_RUNTEST="$ac_prog"
7116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7117     break 2
7118   fi
7119 done
7120 done
7121
7122 fi
7123 fi
7124 RUNTEST=$ac_cv_prog_RUNTEST
7125 if test -n "$RUNTEST"; then
7126   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7127 echo "${ECHO_T}$RUNTEST" >&6
7128 else
7129   echo "$as_me:$LINENO: result: no" >&5
7130 echo "${ECHO_T}no" >&6
7131 fi
7132
7133   test -n "$RUNTEST" && break
7134 done
7135 test -n "$RUNTEST" || RUNTEST="runtest"
7136
7137 case " $configdirs " in
7138   *" dejagnu "*)
7139     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7140     ;;
7141 esac
7142
7143
7144 # Host tools.
7145 ncn_tool_prefix=
7146 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7147 ncn_target_tool_prefix=
7148 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7149
7150
7151
7152 if test -n "$AR"; then
7153   ac_cv_prog_AR=$AR
7154 elif test -n "$ac_cv_prog_AR"; then
7155   AR=$ac_cv_prog_AR
7156 fi
7157
7158 if test -n "$ac_cv_prog_AR"; then
7159   for ncn_progname in ar; do
7160     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7161 set dummy ${ncn_progname}; ac_word=$2
7162 echo "$as_me:$LINENO: checking for $ac_word" >&5
7163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7164 if test "${ac_cv_prog_AR+set}" = set; then
7165   echo $ECHO_N "(cached) $ECHO_C" >&6
7166 else
7167   if test -n "$AR"; then
7168   ac_cv_prog_AR="$AR" # Let the user override the test.
7169 else
7170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7171 for as_dir in $PATH
7172 do
7173   IFS=$as_save_IFS
7174   test -z "$as_dir" && as_dir=.
7175   for ac_exec_ext in '' $ac_executable_extensions; do
7176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7177     ac_cv_prog_AR="${ncn_progname}"
7178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7179     break 2
7180   fi
7181 done
7182 done
7183
7184 fi
7185 fi
7186 AR=$ac_cv_prog_AR
7187 if test -n "$AR"; then
7188   echo "$as_me:$LINENO: result: $AR" >&5
7189 echo "${ECHO_T}$AR" >&6
7190 else
7191   echo "$as_me:$LINENO: result: no" >&5
7192 echo "${ECHO_T}no" >&6
7193 fi
7194
7195   done
7196 fi
7197
7198 for ncn_progname in ar; do
7199   if test -n "$ncn_tool_prefix"; then
7200     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7201 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7202 echo "$as_me:$LINENO: checking for $ac_word" >&5
7203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7204 if test "${ac_cv_prog_AR+set}" = set; then
7205   echo $ECHO_N "(cached) $ECHO_C" >&6
7206 else
7207   if test -n "$AR"; then
7208   ac_cv_prog_AR="$AR" # Let the user override the test.
7209 else
7210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7211 for as_dir in $PATH
7212 do
7213   IFS=$as_save_IFS
7214   test -z "$as_dir" && as_dir=.
7215   for ac_exec_ext in '' $ac_executable_extensions; do
7216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7217     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7219     break 2
7220   fi
7221 done
7222 done
7223
7224 fi
7225 fi
7226 AR=$ac_cv_prog_AR
7227 if test -n "$AR"; then
7228   echo "$as_me:$LINENO: result: $AR" >&5
7229 echo "${ECHO_T}$AR" >&6
7230 else
7231   echo "$as_me:$LINENO: result: no" >&5
7232 echo "${ECHO_T}no" >&6
7233 fi
7234
7235   fi
7236   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7237     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7238 set dummy ${ncn_progname}; ac_word=$2
7239 echo "$as_me:$LINENO: checking for $ac_word" >&5
7240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7241 if test "${ac_cv_prog_AR+set}" = set; then
7242   echo $ECHO_N "(cached) $ECHO_C" >&6
7243 else
7244   if test -n "$AR"; then
7245   ac_cv_prog_AR="$AR" # Let the user override the test.
7246 else
7247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7248 for as_dir in $PATH
7249 do
7250   IFS=$as_save_IFS
7251   test -z "$as_dir" && as_dir=.
7252   for ac_exec_ext in '' $ac_executable_extensions; do
7253   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7254     ac_cv_prog_AR="${ncn_progname}"
7255     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7256     break 2
7257   fi
7258 done
7259 done
7260
7261 fi
7262 fi
7263 AR=$ac_cv_prog_AR
7264 if test -n "$AR"; then
7265   echo "$as_me:$LINENO: result: $AR" >&5
7266 echo "${ECHO_T}$AR" >&6
7267 else
7268   echo "$as_me:$LINENO: result: no" >&5
7269 echo "${ECHO_T}no" >&6
7270 fi
7271
7272   fi
7273   test -n "$ac_cv_prog_AR" && break
7274 done
7275
7276 if test -z "$ac_cv_prog_AR" ; then
7277   set dummy ar
7278   if test $build = $host ; then
7279     AR="$2"
7280   else
7281     AR="${ncn_tool_prefix}$2"
7282   fi
7283 fi
7284
7285
7286
7287 if test -n "$AS"; then
7288   ac_cv_prog_AS=$AS
7289 elif test -n "$ac_cv_prog_AS"; then
7290   AS=$ac_cv_prog_AS
7291 fi
7292
7293 if test -n "$ac_cv_prog_AS"; then
7294   for ncn_progname in as; do
7295     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7296 set dummy ${ncn_progname}; ac_word=$2
7297 echo "$as_me:$LINENO: checking for $ac_word" >&5
7298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7299 if test "${ac_cv_prog_AS+set}" = set; then
7300   echo $ECHO_N "(cached) $ECHO_C" >&6
7301 else
7302   if test -n "$AS"; then
7303   ac_cv_prog_AS="$AS" # Let the user override the test.
7304 else
7305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7306 for as_dir in $PATH
7307 do
7308   IFS=$as_save_IFS
7309   test -z "$as_dir" && as_dir=.
7310   for ac_exec_ext in '' $ac_executable_extensions; do
7311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7312     ac_cv_prog_AS="${ncn_progname}"
7313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7314     break 2
7315   fi
7316 done
7317 done
7318
7319 fi
7320 fi
7321 AS=$ac_cv_prog_AS
7322 if test -n "$AS"; then
7323   echo "$as_me:$LINENO: result: $AS" >&5
7324 echo "${ECHO_T}$AS" >&6
7325 else
7326   echo "$as_me:$LINENO: result: no" >&5
7327 echo "${ECHO_T}no" >&6
7328 fi
7329
7330   done
7331 fi
7332
7333 for ncn_progname in as; do
7334   if test -n "$ncn_tool_prefix"; then
7335     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7336 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7337 echo "$as_me:$LINENO: checking for $ac_word" >&5
7338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7339 if test "${ac_cv_prog_AS+set}" = set; then
7340   echo $ECHO_N "(cached) $ECHO_C" >&6
7341 else
7342   if test -n "$AS"; then
7343   ac_cv_prog_AS="$AS" # Let the user override the test.
7344 else
7345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7346 for as_dir in $PATH
7347 do
7348   IFS=$as_save_IFS
7349   test -z "$as_dir" && as_dir=.
7350   for ac_exec_ext in '' $ac_executable_extensions; do
7351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7352     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7354     break 2
7355   fi
7356 done
7357 done
7358
7359 fi
7360 fi
7361 AS=$ac_cv_prog_AS
7362 if test -n "$AS"; then
7363   echo "$as_me:$LINENO: result: $AS" >&5
7364 echo "${ECHO_T}$AS" >&6
7365 else
7366   echo "$as_me:$LINENO: result: no" >&5
7367 echo "${ECHO_T}no" >&6
7368 fi
7369
7370   fi
7371   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7372     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7373 set dummy ${ncn_progname}; ac_word=$2
7374 echo "$as_me:$LINENO: checking for $ac_word" >&5
7375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7376 if test "${ac_cv_prog_AS+set}" = set; then
7377   echo $ECHO_N "(cached) $ECHO_C" >&6
7378 else
7379   if test -n "$AS"; then
7380   ac_cv_prog_AS="$AS" # Let the user override the test.
7381 else
7382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7383 for as_dir in $PATH
7384 do
7385   IFS=$as_save_IFS
7386   test -z "$as_dir" && as_dir=.
7387   for ac_exec_ext in '' $ac_executable_extensions; do
7388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7389     ac_cv_prog_AS="${ncn_progname}"
7390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7391     break 2
7392   fi
7393 done
7394 done
7395
7396 fi
7397 fi
7398 AS=$ac_cv_prog_AS
7399 if test -n "$AS"; then
7400   echo "$as_me:$LINENO: result: $AS" >&5
7401 echo "${ECHO_T}$AS" >&6
7402 else
7403   echo "$as_me:$LINENO: result: no" >&5
7404 echo "${ECHO_T}no" >&6
7405 fi
7406
7407   fi
7408   test -n "$ac_cv_prog_AS" && break
7409 done
7410
7411 if test -z "$ac_cv_prog_AS" ; then
7412   set dummy as
7413   if test $build = $host ; then
7414     AS="$2"
7415   else
7416     AS="${ncn_tool_prefix}$2"
7417   fi
7418 fi
7419
7420
7421
7422 if test -n "$DLLTOOL"; then
7423   ac_cv_prog_DLLTOOL=$DLLTOOL
7424 elif test -n "$ac_cv_prog_DLLTOOL"; then
7425   DLLTOOL=$ac_cv_prog_DLLTOOL
7426 fi
7427
7428 if test -n "$ac_cv_prog_DLLTOOL"; then
7429   for ncn_progname in dlltool; do
7430     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7431 set dummy ${ncn_progname}; ac_word=$2
7432 echo "$as_me:$LINENO: checking for $ac_word" >&5
7433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7434 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7435   echo $ECHO_N "(cached) $ECHO_C" >&6
7436 else
7437   if test -n "$DLLTOOL"; then
7438   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7439 else
7440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7441 for as_dir in $PATH
7442 do
7443   IFS=$as_save_IFS
7444   test -z "$as_dir" && as_dir=.
7445   for ac_exec_ext in '' $ac_executable_extensions; do
7446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7447     ac_cv_prog_DLLTOOL="${ncn_progname}"
7448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7449     break 2
7450   fi
7451 done
7452 done
7453
7454 fi
7455 fi
7456 DLLTOOL=$ac_cv_prog_DLLTOOL
7457 if test -n "$DLLTOOL"; then
7458   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7459 echo "${ECHO_T}$DLLTOOL" >&6
7460 else
7461   echo "$as_me:$LINENO: result: no" >&5
7462 echo "${ECHO_T}no" >&6
7463 fi
7464
7465   done
7466 fi
7467
7468 for ncn_progname in dlltool; do
7469   if test -n "$ncn_tool_prefix"; then
7470     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7471 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7472 echo "$as_me:$LINENO: checking for $ac_word" >&5
7473 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7474 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7475   echo $ECHO_N "(cached) $ECHO_C" >&6
7476 else
7477   if test -n "$DLLTOOL"; then
7478   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7479 else
7480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7481 for as_dir in $PATH
7482 do
7483   IFS=$as_save_IFS
7484   test -z "$as_dir" && as_dir=.
7485   for ac_exec_ext in '' $ac_executable_extensions; do
7486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7487     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7489     break 2
7490   fi
7491 done
7492 done
7493
7494 fi
7495 fi
7496 DLLTOOL=$ac_cv_prog_DLLTOOL
7497 if test -n "$DLLTOOL"; then
7498   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7499 echo "${ECHO_T}$DLLTOOL" >&6
7500 else
7501   echo "$as_me:$LINENO: result: no" >&5
7502 echo "${ECHO_T}no" >&6
7503 fi
7504
7505   fi
7506   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7507     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7508 set dummy ${ncn_progname}; ac_word=$2
7509 echo "$as_me:$LINENO: checking for $ac_word" >&5
7510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7511 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7512   echo $ECHO_N "(cached) $ECHO_C" >&6
7513 else
7514   if test -n "$DLLTOOL"; then
7515   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7516 else
7517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7518 for as_dir in $PATH
7519 do
7520   IFS=$as_save_IFS
7521   test -z "$as_dir" && as_dir=.
7522   for ac_exec_ext in '' $ac_executable_extensions; do
7523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7524     ac_cv_prog_DLLTOOL="${ncn_progname}"
7525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7526     break 2
7527   fi
7528 done
7529 done
7530
7531 fi
7532 fi
7533 DLLTOOL=$ac_cv_prog_DLLTOOL
7534 if test -n "$DLLTOOL"; then
7535   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7536 echo "${ECHO_T}$DLLTOOL" >&6
7537 else
7538   echo "$as_me:$LINENO: result: no" >&5
7539 echo "${ECHO_T}no" >&6
7540 fi
7541
7542   fi
7543   test -n "$ac_cv_prog_DLLTOOL" && break
7544 done
7545
7546 if test -z "$ac_cv_prog_DLLTOOL" ; then
7547   set dummy dlltool
7548   if test $build = $host ; then
7549     DLLTOOL="$2"
7550   else
7551     DLLTOOL="${ncn_tool_prefix}$2"
7552   fi
7553 fi
7554
7555
7556
7557 if test -n "$LD"; then
7558   ac_cv_prog_LD=$LD
7559 elif test -n "$ac_cv_prog_LD"; then
7560   LD=$ac_cv_prog_LD
7561 fi
7562
7563 if test -n "$ac_cv_prog_LD"; then
7564   for ncn_progname in ld; do
7565     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7566 set dummy ${ncn_progname}; ac_word=$2
7567 echo "$as_me:$LINENO: checking for $ac_word" >&5
7568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7569 if test "${ac_cv_prog_LD+set}" = set; then
7570   echo $ECHO_N "(cached) $ECHO_C" >&6
7571 else
7572   if test -n "$LD"; then
7573   ac_cv_prog_LD="$LD" # Let the user override the test.
7574 else
7575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7576 for as_dir in $PATH
7577 do
7578   IFS=$as_save_IFS
7579   test -z "$as_dir" && as_dir=.
7580   for ac_exec_ext in '' $ac_executable_extensions; do
7581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7582     ac_cv_prog_LD="${ncn_progname}"
7583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7584     break 2
7585   fi
7586 done
7587 done
7588
7589 fi
7590 fi
7591 LD=$ac_cv_prog_LD
7592 if test -n "$LD"; then
7593   echo "$as_me:$LINENO: result: $LD" >&5
7594 echo "${ECHO_T}$LD" >&6
7595 else
7596   echo "$as_me:$LINENO: result: no" >&5
7597 echo "${ECHO_T}no" >&6
7598 fi
7599
7600   done
7601 fi
7602
7603 for ncn_progname in ld; do
7604   if test -n "$ncn_tool_prefix"; then
7605     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7606 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7607 echo "$as_me:$LINENO: checking for $ac_word" >&5
7608 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7609 if test "${ac_cv_prog_LD+set}" = set; then
7610   echo $ECHO_N "(cached) $ECHO_C" >&6
7611 else
7612   if test -n "$LD"; then
7613   ac_cv_prog_LD="$LD" # Let the user override the test.
7614 else
7615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7616 for as_dir in $PATH
7617 do
7618   IFS=$as_save_IFS
7619   test -z "$as_dir" && as_dir=.
7620   for ac_exec_ext in '' $ac_executable_extensions; do
7621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7622     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7624     break 2
7625   fi
7626 done
7627 done
7628
7629 fi
7630 fi
7631 LD=$ac_cv_prog_LD
7632 if test -n "$LD"; then
7633   echo "$as_me:$LINENO: result: $LD" >&5
7634 echo "${ECHO_T}$LD" >&6
7635 else
7636   echo "$as_me:$LINENO: result: no" >&5
7637 echo "${ECHO_T}no" >&6
7638 fi
7639
7640   fi
7641   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7642     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7643 set dummy ${ncn_progname}; ac_word=$2
7644 echo "$as_me:$LINENO: checking for $ac_word" >&5
7645 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7646 if test "${ac_cv_prog_LD+set}" = set; then
7647   echo $ECHO_N "(cached) $ECHO_C" >&6
7648 else
7649   if test -n "$LD"; then
7650   ac_cv_prog_LD="$LD" # Let the user override the test.
7651 else
7652 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7653 for as_dir in $PATH
7654 do
7655   IFS=$as_save_IFS
7656   test -z "$as_dir" && as_dir=.
7657   for ac_exec_ext in '' $ac_executable_extensions; do
7658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7659     ac_cv_prog_LD="${ncn_progname}"
7660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7661     break 2
7662   fi
7663 done
7664 done
7665
7666 fi
7667 fi
7668 LD=$ac_cv_prog_LD
7669 if test -n "$LD"; then
7670   echo "$as_me:$LINENO: result: $LD" >&5
7671 echo "${ECHO_T}$LD" >&6
7672 else
7673   echo "$as_me:$LINENO: result: no" >&5
7674 echo "${ECHO_T}no" >&6
7675 fi
7676
7677   fi
7678   test -n "$ac_cv_prog_LD" && break
7679 done
7680
7681 if test -z "$ac_cv_prog_LD" ; then
7682   set dummy ld
7683   if test $build = $host ; then
7684     LD="$2"
7685   else
7686     LD="${ncn_tool_prefix}$2"
7687   fi
7688 fi
7689
7690
7691
7692 if test -n "$LIPO"; then
7693   ac_cv_prog_LIPO=$LIPO
7694 elif test -n "$ac_cv_prog_LIPO"; then
7695   LIPO=$ac_cv_prog_LIPO
7696 fi
7697
7698 if test -n "$ac_cv_prog_LIPO"; then
7699   for ncn_progname in lipo; do
7700     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7701 set dummy ${ncn_progname}; ac_word=$2
7702 echo "$as_me:$LINENO: checking for $ac_word" >&5
7703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7704 if test "${ac_cv_prog_LIPO+set}" = set; then
7705   echo $ECHO_N "(cached) $ECHO_C" >&6
7706 else
7707   if test -n "$LIPO"; then
7708   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7709 else
7710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7711 for as_dir in $PATH
7712 do
7713   IFS=$as_save_IFS
7714   test -z "$as_dir" && as_dir=.
7715   for ac_exec_ext in '' $ac_executable_extensions; do
7716   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7717     ac_cv_prog_LIPO="${ncn_progname}"
7718     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7719     break 2
7720   fi
7721 done
7722 done
7723
7724 fi
7725 fi
7726 LIPO=$ac_cv_prog_LIPO
7727 if test -n "$LIPO"; then
7728   echo "$as_me:$LINENO: result: $LIPO" >&5
7729 echo "${ECHO_T}$LIPO" >&6
7730 else
7731   echo "$as_me:$LINENO: result: no" >&5
7732 echo "${ECHO_T}no" >&6
7733 fi
7734
7735   done
7736 fi
7737
7738 for ncn_progname in lipo; do
7739   if test -n "$ncn_tool_prefix"; then
7740     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7741 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7742 echo "$as_me:$LINENO: checking for $ac_word" >&5
7743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7744 if test "${ac_cv_prog_LIPO+set}" = set; then
7745   echo $ECHO_N "(cached) $ECHO_C" >&6
7746 else
7747   if test -n "$LIPO"; then
7748   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7749 else
7750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7751 for as_dir in $PATH
7752 do
7753   IFS=$as_save_IFS
7754   test -z "$as_dir" && as_dir=.
7755   for ac_exec_ext in '' $ac_executable_extensions; do
7756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7757     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7759     break 2
7760   fi
7761 done
7762 done
7763
7764 fi
7765 fi
7766 LIPO=$ac_cv_prog_LIPO
7767 if test -n "$LIPO"; then
7768   echo "$as_me:$LINENO: result: $LIPO" >&5
7769 echo "${ECHO_T}$LIPO" >&6
7770 else
7771   echo "$as_me:$LINENO: result: no" >&5
7772 echo "${ECHO_T}no" >&6
7773 fi
7774
7775   fi
7776   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7777     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7778 set dummy ${ncn_progname}; ac_word=$2
7779 echo "$as_me:$LINENO: checking for $ac_word" >&5
7780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7781 if test "${ac_cv_prog_LIPO+set}" = set; then
7782   echo $ECHO_N "(cached) $ECHO_C" >&6
7783 else
7784   if test -n "$LIPO"; then
7785   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7786 else
7787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7788 for as_dir in $PATH
7789 do
7790   IFS=$as_save_IFS
7791   test -z "$as_dir" && as_dir=.
7792   for ac_exec_ext in '' $ac_executable_extensions; do
7793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7794     ac_cv_prog_LIPO="${ncn_progname}"
7795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7796     break 2
7797   fi
7798 done
7799 done
7800
7801 fi
7802 fi
7803 LIPO=$ac_cv_prog_LIPO
7804 if test -n "$LIPO"; then
7805   echo "$as_me:$LINENO: result: $LIPO" >&5
7806 echo "${ECHO_T}$LIPO" >&6
7807 else
7808   echo "$as_me:$LINENO: result: no" >&5
7809 echo "${ECHO_T}no" >&6
7810 fi
7811
7812   fi
7813   test -n "$ac_cv_prog_LIPO" && break
7814 done
7815
7816 if test -z "$ac_cv_prog_LIPO" ; then
7817   set dummy lipo
7818   if test $build = $host ; then
7819     LIPO="$2"
7820   else
7821     LIPO="${ncn_tool_prefix}$2"
7822   fi
7823 fi
7824
7825
7826
7827 if test -n "$NM"; then
7828   ac_cv_prog_NM=$NM
7829 elif test -n "$ac_cv_prog_NM"; then
7830   NM=$ac_cv_prog_NM
7831 fi
7832
7833 if test -n "$ac_cv_prog_NM"; then
7834   for ncn_progname in nm; do
7835     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7836 set dummy ${ncn_progname}; ac_word=$2
7837 echo "$as_me:$LINENO: checking for $ac_word" >&5
7838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7839 if test "${ac_cv_prog_NM+set}" = set; then
7840   echo $ECHO_N "(cached) $ECHO_C" >&6
7841 else
7842   if test -n "$NM"; then
7843   ac_cv_prog_NM="$NM" # Let the user override the test.
7844 else
7845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7846 for as_dir in $PATH
7847 do
7848   IFS=$as_save_IFS
7849   test -z "$as_dir" && as_dir=.
7850   for ac_exec_ext in '' $ac_executable_extensions; do
7851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7852     ac_cv_prog_NM="${ncn_progname}"
7853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7854     break 2
7855   fi
7856 done
7857 done
7858
7859 fi
7860 fi
7861 NM=$ac_cv_prog_NM
7862 if test -n "$NM"; then
7863   echo "$as_me:$LINENO: result: $NM" >&5
7864 echo "${ECHO_T}$NM" >&6
7865 else
7866   echo "$as_me:$LINENO: result: no" >&5
7867 echo "${ECHO_T}no" >&6
7868 fi
7869
7870   done
7871 fi
7872
7873 for ncn_progname in nm; do
7874   if test -n "$ncn_tool_prefix"; then
7875     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7876 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7877 echo "$as_me:$LINENO: checking for $ac_word" >&5
7878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7879 if test "${ac_cv_prog_NM+set}" = set; then
7880   echo $ECHO_N "(cached) $ECHO_C" >&6
7881 else
7882   if test -n "$NM"; then
7883   ac_cv_prog_NM="$NM" # Let the user override the test.
7884 else
7885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7886 for as_dir in $PATH
7887 do
7888   IFS=$as_save_IFS
7889   test -z "$as_dir" && as_dir=.
7890   for ac_exec_ext in '' $ac_executable_extensions; do
7891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7892     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7894     break 2
7895   fi
7896 done
7897 done
7898
7899 fi
7900 fi
7901 NM=$ac_cv_prog_NM
7902 if test -n "$NM"; then
7903   echo "$as_me:$LINENO: result: $NM" >&5
7904 echo "${ECHO_T}$NM" >&6
7905 else
7906   echo "$as_me:$LINENO: result: no" >&5
7907 echo "${ECHO_T}no" >&6
7908 fi
7909
7910   fi
7911   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7912     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7913 set dummy ${ncn_progname}; ac_word=$2
7914 echo "$as_me:$LINENO: checking for $ac_word" >&5
7915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7916 if test "${ac_cv_prog_NM+set}" = set; then
7917   echo $ECHO_N "(cached) $ECHO_C" >&6
7918 else
7919   if test -n "$NM"; then
7920   ac_cv_prog_NM="$NM" # Let the user override the test.
7921 else
7922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7923 for as_dir in $PATH
7924 do
7925   IFS=$as_save_IFS
7926   test -z "$as_dir" && as_dir=.
7927   for ac_exec_ext in '' $ac_executable_extensions; do
7928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7929     ac_cv_prog_NM="${ncn_progname}"
7930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7931     break 2
7932   fi
7933 done
7934 done
7935
7936 fi
7937 fi
7938 NM=$ac_cv_prog_NM
7939 if test -n "$NM"; then
7940   echo "$as_me:$LINENO: result: $NM" >&5
7941 echo "${ECHO_T}$NM" >&6
7942 else
7943   echo "$as_me:$LINENO: result: no" >&5
7944 echo "${ECHO_T}no" >&6
7945 fi
7946
7947   fi
7948   test -n "$ac_cv_prog_NM" && break
7949 done
7950
7951 if test -z "$ac_cv_prog_NM" ; then
7952   set dummy nm
7953   if test $build = $host ; then
7954     NM="$2"
7955   else
7956     NM="${ncn_tool_prefix}$2"
7957   fi
7958 fi
7959
7960
7961
7962 if test -n "$RANLIB"; then
7963   ac_cv_prog_RANLIB=$RANLIB
7964 elif test -n "$ac_cv_prog_RANLIB"; then
7965   RANLIB=$ac_cv_prog_RANLIB
7966 fi
7967
7968 if test -n "$ac_cv_prog_RANLIB"; then
7969   for ncn_progname in ranlib; do
7970     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7971 set dummy ${ncn_progname}; ac_word=$2
7972 echo "$as_me:$LINENO: checking for $ac_word" >&5
7973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7974 if test "${ac_cv_prog_RANLIB+set}" = set; then
7975   echo $ECHO_N "(cached) $ECHO_C" >&6
7976 else
7977   if test -n "$RANLIB"; then
7978   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7979 else
7980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7981 for as_dir in $PATH
7982 do
7983   IFS=$as_save_IFS
7984   test -z "$as_dir" && as_dir=.
7985   for ac_exec_ext in '' $ac_executable_extensions; do
7986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7987     ac_cv_prog_RANLIB="${ncn_progname}"
7988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7989     break 2
7990   fi
7991 done
7992 done
7993
7994 fi
7995 fi
7996 RANLIB=$ac_cv_prog_RANLIB
7997 if test -n "$RANLIB"; then
7998   echo "$as_me:$LINENO: result: $RANLIB" >&5
7999 echo "${ECHO_T}$RANLIB" >&6
8000 else
8001   echo "$as_me:$LINENO: result: no" >&5
8002 echo "${ECHO_T}no" >&6
8003 fi
8004
8005   done
8006 fi
8007
8008 for ncn_progname in ranlib; do
8009   if test -n "$ncn_tool_prefix"; then
8010     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8011 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8012 echo "$as_me:$LINENO: checking for $ac_word" >&5
8013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8014 if test "${ac_cv_prog_RANLIB+set}" = set; then
8015   echo $ECHO_N "(cached) $ECHO_C" >&6
8016 else
8017   if test -n "$RANLIB"; then
8018   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8019 else
8020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8021 for as_dir in $PATH
8022 do
8023   IFS=$as_save_IFS
8024   test -z "$as_dir" && as_dir=.
8025   for ac_exec_ext in '' $ac_executable_extensions; do
8026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8027     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
8028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8029     break 2
8030   fi
8031 done
8032 done
8033
8034 fi
8035 fi
8036 RANLIB=$ac_cv_prog_RANLIB
8037 if test -n "$RANLIB"; then
8038   echo "$as_me:$LINENO: result: $RANLIB" >&5
8039 echo "${ECHO_T}$RANLIB" >&6
8040 else
8041   echo "$as_me:$LINENO: result: no" >&5
8042 echo "${ECHO_T}no" >&6
8043 fi
8044
8045   fi
8046   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
8047     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8048 set dummy ${ncn_progname}; ac_word=$2
8049 echo "$as_me:$LINENO: checking for $ac_word" >&5
8050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8051 if test "${ac_cv_prog_RANLIB+set}" = set; then
8052   echo $ECHO_N "(cached) $ECHO_C" >&6
8053 else
8054   if test -n "$RANLIB"; then
8055   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8056 else
8057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8058 for as_dir in $PATH
8059 do
8060   IFS=$as_save_IFS
8061   test -z "$as_dir" && as_dir=.
8062   for ac_exec_ext in '' $ac_executable_extensions; do
8063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8064     ac_cv_prog_RANLIB="${ncn_progname}"
8065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8066     break 2
8067   fi
8068 done
8069 done
8070
8071 fi
8072 fi
8073 RANLIB=$ac_cv_prog_RANLIB
8074 if test -n "$RANLIB"; then
8075   echo "$as_me:$LINENO: result: $RANLIB" >&5
8076 echo "${ECHO_T}$RANLIB" >&6
8077 else
8078   echo "$as_me:$LINENO: result: no" >&5
8079 echo "${ECHO_T}no" >&6
8080 fi
8081
8082   fi
8083   test -n "$ac_cv_prog_RANLIB" && break
8084 done
8085
8086 if test -z "$ac_cv_prog_RANLIB" ; then
8087   RANLIB=":"
8088 fi
8089
8090
8091
8092 if test -n "$STRIP"; then
8093   ac_cv_prog_STRIP=$STRIP
8094 elif test -n "$ac_cv_prog_STRIP"; then
8095   STRIP=$ac_cv_prog_STRIP
8096 fi
8097
8098 if test -n "$ac_cv_prog_STRIP"; then
8099   for ncn_progname in strip; do
8100     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8101 set dummy ${ncn_progname}; ac_word=$2
8102 echo "$as_me:$LINENO: checking for $ac_word" >&5
8103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8104 if test "${ac_cv_prog_STRIP+set}" = set; then
8105   echo $ECHO_N "(cached) $ECHO_C" >&6
8106 else
8107   if test -n "$STRIP"; then
8108   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8109 else
8110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8111 for as_dir in $PATH
8112 do
8113   IFS=$as_save_IFS
8114   test -z "$as_dir" && as_dir=.
8115   for ac_exec_ext in '' $ac_executable_extensions; do
8116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8117     ac_cv_prog_STRIP="${ncn_progname}"
8118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8119     break 2
8120   fi
8121 done
8122 done
8123
8124 fi
8125 fi
8126 STRIP=$ac_cv_prog_STRIP
8127 if test -n "$STRIP"; then
8128   echo "$as_me:$LINENO: result: $STRIP" >&5
8129 echo "${ECHO_T}$STRIP" >&6
8130 else
8131   echo "$as_me:$LINENO: result: no" >&5
8132 echo "${ECHO_T}no" >&6
8133 fi
8134
8135   done
8136 fi
8137
8138 for ncn_progname in strip; do
8139   if test -n "$ncn_tool_prefix"; then
8140     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8141 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8142 echo "$as_me:$LINENO: checking for $ac_word" >&5
8143 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8144 if test "${ac_cv_prog_STRIP+set}" = set; then
8145   echo $ECHO_N "(cached) $ECHO_C" >&6
8146 else
8147   if test -n "$STRIP"; then
8148   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8149 else
8150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8151 for as_dir in $PATH
8152 do
8153   IFS=$as_save_IFS
8154   test -z "$as_dir" && as_dir=.
8155   for ac_exec_ext in '' $ac_executable_extensions; do
8156   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8157     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8158     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8159     break 2
8160   fi
8161 done
8162 done
8163
8164 fi
8165 fi
8166 STRIP=$ac_cv_prog_STRIP
8167 if test -n "$STRIP"; then
8168   echo "$as_me:$LINENO: result: $STRIP" >&5
8169 echo "${ECHO_T}$STRIP" >&6
8170 else
8171   echo "$as_me:$LINENO: result: no" >&5
8172 echo "${ECHO_T}no" >&6
8173 fi
8174
8175   fi
8176   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8177     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8178 set dummy ${ncn_progname}; ac_word=$2
8179 echo "$as_me:$LINENO: checking for $ac_word" >&5
8180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8181 if test "${ac_cv_prog_STRIP+set}" = set; then
8182   echo $ECHO_N "(cached) $ECHO_C" >&6
8183 else
8184   if test -n "$STRIP"; then
8185   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8186 else
8187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8188 for as_dir in $PATH
8189 do
8190   IFS=$as_save_IFS
8191   test -z "$as_dir" && as_dir=.
8192   for ac_exec_ext in '' $ac_executable_extensions; do
8193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8194     ac_cv_prog_STRIP="${ncn_progname}"
8195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8196     break 2
8197   fi
8198 done
8199 done
8200
8201 fi
8202 fi
8203 STRIP=$ac_cv_prog_STRIP
8204 if test -n "$STRIP"; then
8205   echo "$as_me:$LINENO: result: $STRIP" >&5
8206 echo "${ECHO_T}$STRIP" >&6
8207 else
8208   echo "$as_me:$LINENO: result: no" >&5
8209 echo "${ECHO_T}no" >&6
8210 fi
8211
8212   fi
8213   test -n "$ac_cv_prog_STRIP" && break
8214 done
8215
8216 if test -z "$ac_cv_prog_STRIP" ; then
8217   STRIP=":"
8218 fi
8219
8220
8221
8222 if test -n "$WINDRES"; then
8223   ac_cv_prog_WINDRES=$WINDRES
8224 elif test -n "$ac_cv_prog_WINDRES"; then
8225   WINDRES=$ac_cv_prog_WINDRES
8226 fi
8227
8228 if test -n "$ac_cv_prog_WINDRES"; then
8229   for ncn_progname in windres; do
8230     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8231 set dummy ${ncn_progname}; ac_word=$2
8232 echo "$as_me:$LINENO: checking for $ac_word" >&5
8233 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8234 if test "${ac_cv_prog_WINDRES+set}" = set; then
8235   echo $ECHO_N "(cached) $ECHO_C" >&6
8236 else
8237   if test -n "$WINDRES"; then
8238   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8239 else
8240 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8241 for as_dir in $PATH
8242 do
8243   IFS=$as_save_IFS
8244   test -z "$as_dir" && as_dir=.
8245   for ac_exec_ext in '' $ac_executable_extensions; do
8246   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8247     ac_cv_prog_WINDRES="${ncn_progname}"
8248     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8249     break 2
8250   fi
8251 done
8252 done
8253
8254 fi
8255 fi
8256 WINDRES=$ac_cv_prog_WINDRES
8257 if test -n "$WINDRES"; then
8258   echo "$as_me:$LINENO: result: $WINDRES" >&5
8259 echo "${ECHO_T}$WINDRES" >&6
8260 else
8261   echo "$as_me:$LINENO: result: no" >&5
8262 echo "${ECHO_T}no" >&6
8263 fi
8264
8265   done
8266 fi
8267
8268 for ncn_progname in windres; do
8269   if test -n "$ncn_tool_prefix"; then
8270     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8271 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8272 echo "$as_me:$LINENO: checking for $ac_word" >&5
8273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8274 if test "${ac_cv_prog_WINDRES+set}" = set; then
8275   echo $ECHO_N "(cached) $ECHO_C" >&6
8276 else
8277   if test -n "$WINDRES"; then
8278   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8279 else
8280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8281 for as_dir in $PATH
8282 do
8283   IFS=$as_save_IFS
8284   test -z "$as_dir" && as_dir=.
8285   for ac_exec_ext in '' $ac_executable_extensions; do
8286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8287     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8289     break 2
8290   fi
8291 done
8292 done
8293
8294 fi
8295 fi
8296 WINDRES=$ac_cv_prog_WINDRES
8297 if test -n "$WINDRES"; then
8298   echo "$as_me:$LINENO: result: $WINDRES" >&5
8299 echo "${ECHO_T}$WINDRES" >&6
8300 else
8301   echo "$as_me:$LINENO: result: no" >&5
8302 echo "${ECHO_T}no" >&6
8303 fi
8304
8305   fi
8306   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8307     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8308 set dummy ${ncn_progname}; ac_word=$2
8309 echo "$as_me:$LINENO: checking for $ac_word" >&5
8310 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8311 if test "${ac_cv_prog_WINDRES+set}" = set; then
8312   echo $ECHO_N "(cached) $ECHO_C" >&6
8313 else
8314   if test -n "$WINDRES"; then
8315   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8316 else
8317 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8318 for as_dir in $PATH
8319 do
8320   IFS=$as_save_IFS
8321   test -z "$as_dir" && as_dir=.
8322   for ac_exec_ext in '' $ac_executable_extensions; do
8323   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8324     ac_cv_prog_WINDRES="${ncn_progname}"
8325     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8326     break 2
8327   fi
8328 done
8329 done
8330
8331 fi
8332 fi
8333 WINDRES=$ac_cv_prog_WINDRES
8334 if test -n "$WINDRES"; then
8335   echo "$as_me:$LINENO: result: $WINDRES" >&5
8336 echo "${ECHO_T}$WINDRES" >&6
8337 else
8338   echo "$as_me:$LINENO: result: no" >&5
8339 echo "${ECHO_T}no" >&6
8340 fi
8341
8342   fi
8343   test -n "$ac_cv_prog_WINDRES" && break
8344 done
8345
8346 if test -z "$ac_cv_prog_WINDRES" ; then
8347   set dummy windres
8348   if test $build = $host ; then
8349     WINDRES="$2"
8350   else
8351     WINDRES="${ncn_tool_prefix}$2"
8352   fi
8353 fi
8354
8355
8356
8357 if test -n "$WINDMC"; then
8358   ac_cv_prog_WINDMC=$WINDMC
8359 elif test -n "$ac_cv_prog_WINDMC"; then
8360   WINDMC=$ac_cv_prog_WINDMC
8361 fi
8362
8363 if test -n "$ac_cv_prog_WINDMC"; then
8364   for ncn_progname in windmc; do
8365     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8366 set dummy ${ncn_progname}; ac_word=$2
8367 echo "$as_me:$LINENO: checking for $ac_word" >&5
8368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8369 if test "${ac_cv_prog_WINDMC+set}" = set; then
8370   echo $ECHO_N "(cached) $ECHO_C" >&6
8371 else
8372   if test -n "$WINDMC"; then
8373   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8374 else
8375 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8376 for as_dir in $PATH
8377 do
8378   IFS=$as_save_IFS
8379   test -z "$as_dir" && as_dir=.
8380   for ac_exec_ext in '' $ac_executable_extensions; do
8381   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8382     ac_cv_prog_WINDMC="${ncn_progname}"
8383     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8384     break 2
8385   fi
8386 done
8387 done
8388
8389 fi
8390 fi
8391 WINDMC=$ac_cv_prog_WINDMC
8392 if test -n "$WINDMC"; then
8393   echo "$as_me:$LINENO: result: $WINDMC" >&5
8394 echo "${ECHO_T}$WINDMC" >&6
8395 else
8396   echo "$as_me:$LINENO: result: no" >&5
8397 echo "${ECHO_T}no" >&6
8398 fi
8399
8400   done
8401 fi
8402
8403 for ncn_progname in windmc; do
8404   if test -n "$ncn_tool_prefix"; then
8405     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8406 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8407 echo "$as_me:$LINENO: checking for $ac_word" >&5
8408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8409 if test "${ac_cv_prog_WINDMC+set}" = set; then
8410   echo $ECHO_N "(cached) $ECHO_C" >&6
8411 else
8412   if test -n "$WINDMC"; then
8413   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8414 else
8415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8416 for as_dir in $PATH
8417 do
8418   IFS=$as_save_IFS
8419   test -z "$as_dir" && as_dir=.
8420   for ac_exec_ext in '' $ac_executable_extensions; do
8421   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8422     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8423     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8424     break 2
8425   fi
8426 done
8427 done
8428
8429 fi
8430 fi
8431 WINDMC=$ac_cv_prog_WINDMC
8432 if test -n "$WINDMC"; then
8433   echo "$as_me:$LINENO: result: $WINDMC" >&5
8434 echo "${ECHO_T}$WINDMC" >&6
8435 else
8436   echo "$as_me:$LINENO: result: no" >&5
8437 echo "${ECHO_T}no" >&6
8438 fi
8439
8440   fi
8441   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8442     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8443 set dummy ${ncn_progname}; ac_word=$2
8444 echo "$as_me:$LINENO: checking for $ac_word" >&5
8445 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8446 if test "${ac_cv_prog_WINDMC+set}" = set; then
8447   echo $ECHO_N "(cached) $ECHO_C" >&6
8448 else
8449   if test -n "$WINDMC"; then
8450   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8451 else
8452 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8453 for as_dir in $PATH
8454 do
8455   IFS=$as_save_IFS
8456   test -z "$as_dir" && as_dir=.
8457   for ac_exec_ext in '' $ac_executable_extensions; do
8458   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8459     ac_cv_prog_WINDMC="${ncn_progname}"
8460     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8461     break 2
8462   fi
8463 done
8464 done
8465
8466 fi
8467 fi
8468 WINDMC=$ac_cv_prog_WINDMC
8469 if test -n "$WINDMC"; then
8470   echo "$as_me:$LINENO: result: $WINDMC" >&5
8471 echo "${ECHO_T}$WINDMC" >&6
8472 else
8473   echo "$as_me:$LINENO: result: no" >&5
8474 echo "${ECHO_T}no" >&6
8475 fi
8476
8477   fi
8478   test -n "$ac_cv_prog_WINDMC" && break
8479 done
8480
8481 if test -z "$ac_cv_prog_WINDMC" ; then
8482   set dummy windmc
8483   if test $build = $host ; then
8484     WINDMC="$2"
8485   else
8486     WINDMC="${ncn_tool_prefix}$2"
8487   fi
8488 fi
8489
8490
8491
8492 if test -n "$OBJCOPY"; then
8493   ac_cv_prog_OBJCOPY=$OBJCOPY
8494 elif test -n "$ac_cv_prog_OBJCOPY"; then
8495   OBJCOPY=$ac_cv_prog_OBJCOPY
8496 fi
8497
8498 if test -n "$ac_cv_prog_OBJCOPY"; then
8499   for ncn_progname in objcopy; do
8500     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8501 set dummy ${ncn_progname}; ac_word=$2
8502 echo "$as_me:$LINENO: checking for $ac_word" >&5
8503 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8504 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8505   echo $ECHO_N "(cached) $ECHO_C" >&6
8506 else
8507   if test -n "$OBJCOPY"; then
8508   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8509 else
8510 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8511 for as_dir in $PATH
8512 do
8513   IFS=$as_save_IFS
8514   test -z "$as_dir" && as_dir=.
8515   for ac_exec_ext in '' $ac_executable_extensions; do
8516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8517     ac_cv_prog_OBJCOPY="${ncn_progname}"
8518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8519     break 2
8520   fi
8521 done
8522 done
8523
8524 fi
8525 fi
8526 OBJCOPY=$ac_cv_prog_OBJCOPY
8527 if test -n "$OBJCOPY"; then
8528   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8529 echo "${ECHO_T}$OBJCOPY" >&6
8530 else
8531   echo "$as_me:$LINENO: result: no" >&5
8532 echo "${ECHO_T}no" >&6
8533 fi
8534
8535   done
8536 fi
8537
8538 for ncn_progname in objcopy; do
8539   if test -n "$ncn_tool_prefix"; then
8540     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8541 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8542 echo "$as_me:$LINENO: checking for $ac_word" >&5
8543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8544 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8545   echo $ECHO_N "(cached) $ECHO_C" >&6
8546 else
8547   if test -n "$OBJCOPY"; then
8548   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8549 else
8550 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8551 for as_dir in $PATH
8552 do
8553   IFS=$as_save_IFS
8554   test -z "$as_dir" && as_dir=.
8555   for ac_exec_ext in '' $ac_executable_extensions; do
8556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8557     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8559     break 2
8560   fi
8561 done
8562 done
8563
8564 fi
8565 fi
8566 OBJCOPY=$ac_cv_prog_OBJCOPY
8567 if test -n "$OBJCOPY"; then
8568   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8569 echo "${ECHO_T}$OBJCOPY" >&6
8570 else
8571   echo "$as_me:$LINENO: result: no" >&5
8572 echo "${ECHO_T}no" >&6
8573 fi
8574
8575   fi
8576   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8577     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8578 set dummy ${ncn_progname}; ac_word=$2
8579 echo "$as_me:$LINENO: checking for $ac_word" >&5
8580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8581 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8582   echo $ECHO_N "(cached) $ECHO_C" >&6
8583 else
8584   if test -n "$OBJCOPY"; then
8585   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8586 else
8587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8588 for as_dir in $PATH
8589 do
8590   IFS=$as_save_IFS
8591   test -z "$as_dir" && as_dir=.
8592   for ac_exec_ext in '' $ac_executable_extensions; do
8593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8594     ac_cv_prog_OBJCOPY="${ncn_progname}"
8595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8596     break 2
8597   fi
8598 done
8599 done
8600
8601 fi
8602 fi
8603 OBJCOPY=$ac_cv_prog_OBJCOPY
8604 if test -n "$OBJCOPY"; then
8605   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8606 echo "${ECHO_T}$OBJCOPY" >&6
8607 else
8608   echo "$as_me:$LINENO: result: no" >&5
8609 echo "${ECHO_T}no" >&6
8610 fi
8611
8612   fi
8613   test -n "$ac_cv_prog_OBJCOPY" && break
8614 done
8615
8616 if test -z "$ac_cv_prog_OBJCOPY" ; then
8617   set dummy objcopy
8618   if test $build = $host ; then
8619     OBJCOPY="$2"
8620   else
8621     OBJCOPY="${ncn_tool_prefix}$2"
8622   fi
8623 fi
8624
8625
8626
8627 if test -n "$OBJDUMP"; then
8628   ac_cv_prog_OBJDUMP=$OBJDUMP
8629 elif test -n "$ac_cv_prog_OBJDUMP"; then
8630   OBJDUMP=$ac_cv_prog_OBJDUMP
8631 fi
8632
8633 if test -n "$ac_cv_prog_OBJDUMP"; then
8634   for ncn_progname in objdump; do
8635     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8636 set dummy ${ncn_progname}; ac_word=$2
8637 echo "$as_me:$LINENO: checking for $ac_word" >&5
8638 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8639 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8640   echo $ECHO_N "(cached) $ECHO_C" >&6
8641 else
8642   if test -n "$OBJDUMP"; then
8643   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8644 else
8645 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8646 for as_dir in $PATH
8647 do
8648   IFS=$as_save_IFS
8649   test -z "$as_dir" && as_dir=.
8650   for ac_exec_ext in '' $ac_executable_extensions; do
8651   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8652     ac_cv_prog_OBJDUMP="${ncn_progname}"
8653     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8654     break 2
8655   fi
8656 done
8657 done
8658
8659 fi
8660 fi
8661 OBJDUMP=$ac_cv_prog_OBJDUMP
8662 if test -n "$OBJDUMP"; then
8663   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8664 echo "${ECHO_T}$OBJDUMP" >&6
8665 else
8666   echo "$as_me:$LINENO: result: no" >&5
8667 echo "${ECHO_T}no" >&6
8668 fi
8669
8670   done
8671 fi
8672
8673 for ncn_progname in objdump; do
8674   if test -n "$ncn_tool_prefix"; then
8675     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8676 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8677 echo "$as_me:$LINENO: checking for $ac_word" >&5
8678 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8679 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8680   echo $ECHO_N "(cached) $ECHO_C" >&6
8681 else
8682   if test -n "$OBJDUMP"; then
8683   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8684 else
8685 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8686 for as_dir in $PATH
8687 do
8688   IFS=$as_save_IFS
8689   test -z "$as_dir" && as_dir=.
8690   for ac_exec_ext in '' $ac_executable_extensions; do
8691   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8692     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8693     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8694     break 2
8695   fi
8696 done
8697 done
8698
8699 fi
8700 fi
8701 OBJDUMP=$ac_cv_prog_OBJDUMP
8702 if test -n "$OBJDUMP"; then
8703   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8704 echo "${ECHO_T}$OBJDUMP" >&6
8705 else
8706   echo "$as_me:$LINENO: result: no" >&5
8707 echo "${ECHO_T}no" >&6
8708 fi
8709
8710   fi
8711   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8712     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8713 set dummy ${ncn_progname}; ac_word=$2
8714 echo "$as_me:$LINENO: checking for $ac_word" >&5
8715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8716 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8717   echo $ECHO_N "(cached) $ECHO_C" >&6
8718 else
8719   if test -n "$OBJDUMP"; then
8720   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8721 else
8722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8723 for as_dir in $PATH
8724 do
8725   IFS=$as_save_IFS
8726   test -z "$as_dir" && as_dir=.
8727   for ac_exec_ext in '' $ac_executable_extensions; do
8728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8729     ac_cv_prog_OBJDUMP="${ncn_progname}"
8730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8731     break 2
8732   fi
8733 done
8734 done
8735
8736 fi
8737 fi
8738 OBJDUMP=$ac_cv_prog_OBJDUMP
8739 if test -n "$OBJDUMP"; then
8740   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8741 echo "${ECHO_T}$OBJDUMP" >&6
8742 else
8743   echo "$as_me:$LINENO: result: no" >&5
8744 echo "${ECHO_T}no" >&6
8745 fi
8746
8747   fi
8748   test -n "$ac_cv_prog_OBJDUMP" && break
8749 done
8750
8751 if test -z "$ac_cv_prog_OBJDUMP" ; then
8752   set dummy objdump
8753   if test $build = $host ; then
8754     OBJDUMP="$2"
8755   else
8756     OBJDUMP="${ncn_tool_prefix}$2"
8757   fi
8758 fi
8759
8760
8761
8762
8763
8764
8765 # Target tools.
8766
8767 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8768 if test "${with_build_time_tools+set}" = set; then
8769   withval="$with_build_time_tools"
8770   case x"$withval" in
8771      x/*) ;;
8772      *)
8773        with_build_time_tools=
8774        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8775 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8776        ;;
8777    esac
8778 else
8779   with_build_time_tools=
8780 fi;
8781
8782
8783
8784 if test -n "$CC_FOR_TARGET"; then
8785   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8786 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8787   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8788 fi
8789
8790 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8791   for ncn_progname in cc gcc; do
8792     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8793 set dummy ${ncn_progname}; ac_word=$2
8794 echo "$as_me:$LINENO: checking for $ac_word" >&5
8795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8796 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8797   echo $ECHO_N "(cached) $ECHO_C" >&6
8798 else
8799   if test -n "$CC_FOR_TARGET"; then
8800   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8801 else
8802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8803 for as_dir in $PATH
8804 do
8805   IFS=$as_save_IFS
8806   test -z "$as_dir" && as_dir=.
8807   for ac_exec_ext in '' $ac_executable_extensions; do
8808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8809     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8811     break 2
8812   fi
8813 done
8814 done
8815
8816 fi
8817 fi
8818 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8819 if test -n "$CC_FOR_TARGET"; then
8820   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8821 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8822 else
8823   echo "$as_me:$LINENO: result: no" >&5
8824 echo "${ECHO_T}no" >&6
8825 fi
8826
8827   done
8828 fi
8829
8830 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8831   for ncn_progname in cc gcc; do
8832     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8833 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8834     if test -x $with_build_time_tools/${ncn_progname}; then
8835       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8836       echo "$as_me:$LINENO: result: yes" >&5
8837 echo "${ECHO_T}yes" >&6
8838       break
8839     else
8840       echo "$as_me:$LINENO: result: no" >&5
8841 echo "${ECHO_T}no" >&6
8842     fi
8843   done
8844 fi
8845
8846 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8847   for ncn_progname in cc gcc; do
8848     if test -n "$ncn_target_tool_prefix"; then
8849       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8850 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8851 echo "$as_me:$LINENO: checking for $ac_word" >&5
8852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8853 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8854   echo $ECHO_N "(cached) $ECHO_C" >&6
8855 else
8856   if test -n "$CC_FOR_TARGET"; then
8857   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8858 else
8859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8860 for as_dir in $PATH
8861 do
8862   IFS=$as_save_IFS
8863   test -z "$as_dir" && as_dir=.
8864   for ac_exec_ext in '' $ac_executable_extensions; do
8865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8866     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8868     break 2
8869   fi
8870 done
8871 done
8872
8873 fi
8874 fi
8875 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8876 if test -n "$CC_FOR_TARGET"; then
8877   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8878 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8879 else
8880   echo "$as_me:$LINENO: result: no" >&5
8881 echo "${ECHO_T}no" >&6
8882 fi
8883
8884     fi
8885     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8886       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8887 set dummy ${ncn_progname}; ac_word=$2
8888 echo "$as_me:$LINENO: checking for $ac_word" >&5
8889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8890 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8891   echo $ECHO_N "(cached) $ECHO_C" >&6
8892 else
8893   if test -n "$CC_FOR_TARGET"; then
8894   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8895 else
8896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8897 for as_dir in $PATH
8898 do
8899   IFS=$as_save_IFS
8900   test -z "$as_dir" && as_dir=.
8901   for ac_exec_ext in '' $ac_executable_extensions; do
8902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8903     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8905     break 2
8906   fi
8907 done
8908 done
8909
8910 fi
8911 fi
8912 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8913 if test -n "$CC_FOR_TARGET"; then
8914   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8915 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8916 else
8917   echo "$as_me:$LINENO: result: no" >&5
8918 echo "${ECHO_T}no" >&6
8919 fi
8920
8921     fi
8922     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8923   done
8924 fi
8925
8926 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8927   set dummy cc gcc
8928   if test $build = $target ; then
8929     CC_FOR_TARGET="$2"
8930   else
8931     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8932   fi
8933 else
8934   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8935 fi
8936
8937
8938
8939 if test -n "$CXX_FOR_TARGET"; then
8940   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8941 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8942   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8943 fi
8944
8945 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8946   for ncn_progname in c++ g++ cxx gxx; do
8947     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8948 set dummy ${ncn_progname}; ac_word=$2
8949 echo "$as_me:$LINENO: checking for $ac_word" >&5
8950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8951 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8952   echo $ECHO_N "(cached) $ECHO_C" >&6
8953 else
8954   if test -n "$CXX_FOR_TARGET"; then
8955   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8956 else
8957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8958 for as_dir in $PATH
8959 do
8960   IFS=$as_save_IFS
8961   test -z "$as_dir" && as_dir=.
8962   for ac_exec_ext in '' $ac_executable_extensions; do
8963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8964     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8966     break 2
8967   fi
8968 done
8969 done
8970
8971 fi
8972 fi
8973 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8974 if test -n "$CXX_FOR_TARGET"; then
8975   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8976 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8977 else
8978   echo "$as_me:$LINENO: result: no" >&5
8979 echo "${ECHO_T}no" >&6
8980 fi
8981
8982   done
8983 fi
8984
8985 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8986   for ncn_progname in c++ g++ cxx gxx; do
8987     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8988 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8989     if test -x $with_build_time_tools/${ncn_progname}; then
8990       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8991       echo "$as_me:$LINENO: result: yes" >&5
8992 echo "${ECHO_T}yes" >&6
8993       break
8994     else
8995       echo "$as_me:$LINENO: result: no" >&5
8996 echo "${ECHO_T}no" >&6
8997     fi
8998   done
8999 fi
9000
9001 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
9002   for ncn_progname in c++ g++ cxx gxx; do
9003     if test -n "$ncn_target_tool_prefix"; then
9004       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9005 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9006 echo "$as_me:$LINENO: checking for $ac_word" >&5
9007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9008 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9009   echo $ECHO_N "(cached) $ECHO_C" >&6
9010 else
9011   if test -n "$CXX_FOR_TARGET"; then
9012   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9013 else
9014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9015 for as_dir in $PATH
9016 do
9017   IFS=$as_save_IFS
9018   test -z "$as_dir" && as_dir=.
9019   for ac_exec_ext in '' $ac_executable_extensions; do
9020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9021     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9023     break 2
9024   fi
9025 done
9026 done
9027
9028 fi
9029 fi
9030 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9031 if test -n "$CXX_FOR_TARGET"; then
9032   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9033 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9034 else
9035   echo "$as_me:$LINENO: result: no" >&5
9036 echo "${ECHO_T}no" >&6
9037 fi
9038
9039     fi
9040     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
9041       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9042 set dummy ${ncn_progname}; ac_word=$2
9043 echo "$as_me:$LINENO: checking for $ac_word" >&5
9044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9045 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9046   echo $ECHO_N "(cached) $ECHO_C" >&6
9047 else
9048   if test -n "$CXX_FOR_TARGET"; then
9049   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9050 else
9051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9052 for as_dir in $PATH
9053 do
9054   IFS=$as_save_IFS
9055   test -z "$as_dir" && as_dir=.
9056   for ac_exec_ext in '' $ac_executable_extensions; do
9057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9058     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
9059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9060     break 2
9061   fi
9062 done
9063 done
9064
9065 fi
9066 fi
9067 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9068 if test -n "$CXX_FOR_TARGET"; then
9069   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9070 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9071 else
9072   echo "$as_me:$LINENO: result: no" >&5
9073 echo "${ECHO_T}no" >&6
9074 fi
9075
9076     fi
9077     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
9078   done
9079 fi
9080
9081 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
9082   set dummy c++ g++ cxx gxx
9083   if test $build = $target ; then
9084     CXX_FOR_TARGET="$2"
9085   else
9086     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
9087   fi
9088 else
9089   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
9090 fi
9091
9092
9093
9094 if test -n "$GCC_FOR_TARGET"; then
9095   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
9096 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9097   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9098 fi
9099
9100 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9101   for ncn_progname in gcc; do
9102     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9103 set dummy ${ncn_progname}; ac_word=$2
9104 echo "$as_me:$LINENO: checking for $ac_word" >&5
9105 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9106 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9107   echo $ECHO_N "(cached) $ECHO_C" >&6
9108 else
9109   if test -n "$GCC_FOR_TARGET"; then
9110   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9111 else
9112 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9113 for as_dir in $PATH
9114 do
9115   IFS=$as_save_IFS
9116   test -z "$as_dir" && as_dir=.
9117   for ac_exec_ext in '' $ac_executable_extensions; do
9118   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9119     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9120     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9121     break 2
9122   fi
9123 done
9124 done
9125
9126 fi
9127 fi
9128 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9129 if test -n "$GCC_FOR_TARGET"; then
9130   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9131 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9132 else
9133   echo "$as_me:$LINENO: result: no" >&5
9134 echo "${ECHO_T}no" >&6
9135 fi
9136
9137   done
9138 fi
9139
9140 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9141   for ncn_progname in gcc; do
9142     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9143 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9144     if test -x $with_build_time_tools/${ncn_progname}; then
9145       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9146       echo "$as_me:$LINENO: result: yes" >&5
9147 echo "${ECHO_T}yes" >&6
9148       break
9149     else
9150       echo "$as_me:$LINENO: result: no" >&5
9151 echo "${ECHO_T}no" >&6
9152     fi
9153   done
9154 fi
9155
9156 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9157   for ncn_progname in gcc; do
9158     if test -n "$ncn_target_tool_prefix"; then
9159       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9160 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9161 echo "$as_me:$LINENO: checking for $ac_word" >&5
9162 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9163 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9164   echo $ECHO_N "(cached) $ECHO_C" >&6
9165 else
9166   if test -n "$GCC_FOR_TARGET"; then
9167   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9168 else
9169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9170 for as_dir in $PATH
9171 do
9172   IFS=$as_save_IFS
9173   test -z "$as_dir" && as_dir=.
9174   for ac_exec_ext in '' $ac_executable_extensions; do
9175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9176     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9178     break 2
9179   fi
9180 done
9181 done
9182
9183 fi
9184 fi
9185 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9186 if test -n "$GCC_FOR_TARGET"; then
9187   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9188 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9189 else
9190   echo "$as_me:$LINENO: result: no" >&5
9191 echo "${ECHO_T}no" >&6
9192 fi
9193
9194     fi
9195     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9196       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9197 set dummy ${ncn_progname}; ac_word=$2
9198 echo "$as_me:$LINENO: checking for $ac_word" >&5
9199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9200 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9201   echo $ECHO_N "(cached) $ECHO_C" >&6
9202 else
9203   if test -n "$GCC_FOR_TARGET"; then
9204   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9205 else
9206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9207 for as_dir in $PATH
9208 do
9209   IFS=$as_save_IFS
9210   test -z "$as_dir" && as_dir=.
9211   for ac_exec_ext in '' $ac_executable_extensions; do
9212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9213     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9215     break 2
9216   fi
9217 done
9218 done
9219
9220 fi
9221 fi
9222 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9223 if test -n "$GCC_FOR_TARGET"; then
9224   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9225 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9226 else
9227   echo "$as_me:$LINENO: result: no" >&5
9228 echo "${ECHO_T}no" >&6
9229 fi
9230
9231     fi
9232     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9233   done
9234 fi
9235
9236 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9237   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9238 else
9239   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9240 fi
9241
9242
9243
9244 if test -n "$GCJ_FOR_TARGET"; then
9245   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9246 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9247   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9248 fi
9249
9250 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9251   for ncn_progname in gcj; do
9252     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9253 set dummy ${ncn_progname}; ac_word=$2
9254 echo "$as_me:$LINENO: checking for $ac_word" >&5
9255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9256 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9257   echo $ECHO_N "(cached) $ECHO_C" >&6
9258 else
9259   if test -n "$GCJ_FOR_TARGET"; then
9260   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9261 else
9262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9263 for as_dir in $PATH
9264 do
9265   IFS=$as_save_IFS
9266   test -z "$as_dir" && as_dir=.
9267   for ac_exec_ext in '' $ac_executable_extensions; do
9268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9269     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9271     break 2
9272   fi
9273 done
9274 done
9275
9276 fi
9277 fi
9278 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9279 if test -n "$GCJ_FOR_TARGET"; then
9280   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9281 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9282 else
9283   echo "$as_me:$LINENO: result: no" >&5
9284 echo "${ECHO_T}no" >&6
9285 fi
9286
9287   done
9288 fi
9289
9290 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9291   for ncn_progname in gcj; do
9292     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9293 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9294     if test -x $with_build_time_tools/${ncn_progname}; then
9295       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9296       echo "$as_me:$LINENO: result: yes" >&5
9297 echo "${ECHO_T}yes" >&6
9298       break
9299     else
9300       echo "$as_me:$LINENO: result: no" >&5
9301 echo "${ECHO_T}no" >&6
9302     fi
9303   done
9304 fi
9305
9306 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9307   for ncn_progname in gcj; do
9308     if test -n "$ncn_target_tool_prefix"; then
9309       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9310 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9311 echo "$as_me:$LINENO: checking for $ac_word" >&5
9312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9313 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9314   echo $ECHO_N "(cached) $ECHO_C" >&6
9315 else
9316   if test -n "$GCJ_FOR_TARGET"; then
9317   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9318 else
9319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9320 for as_dir in $PATH
9321 do
9322   IFS=$as_save_IFS
9323   test -z "$as_dir" && as_dir=.
9324   for ac_exec_ext in '' $ac_executable_extensions; do
9325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9326     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9328     break 2
9329   fi
9330 done
9331 done
9332
9333 fi
9334 fi
9335 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9336 if test -n "$GCJ_FOR_TARGET"; then
9337   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9338 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9339 else
9340   echo "$as_me:$LINENO: result: no" >&5
9341 echo "${ECHO_T}no" >&6
9342 fi
9343
9344     fi
9345     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9346       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9347 set dummy ${ncn_progname}; ac_word=$2
9348 echo "$as_me:$LINENO: checking for $ac_word" >&5
9349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9350 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9351   echo $ECHO_N "(cached) $ECHO_C" >&6
9352 else
9353   if test -n "$GCJ_FOR_TARGET"; then
9354   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9355 else
9356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9357 for as_dir in $PATH
9358 do
9359   IFS=$as_save_IFS
9360   test -z "$as_dir" && as_dir=.
9361   for ac_exec_ext in '' $ac_executable_extensions; do
9362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9363     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9365     break 2
9366   fi
9367 done
9368 done
9369
9370 fi
9371 fi
9372 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9373 if test -n "$GCJ_FOR_TARGET"; then
9374   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9375 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9376 else
9377   echo "$as_me:$LINENO: result: no" >&5
9378 echo "${ECHO_T}no" >&6
9379 fi
9380
9381     fi
9382     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9383   done
9384 fi
9385
9386 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9387   set dummy gcj
9388   if test $build = $target ; then
9389     GCJ_FOR_TARGET="$2"
9390   else
9391     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9392   fi
9393 else
9394   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9395 fi
9396
9397
9398
9399 if test -n "$GFORTRAN_FOR_TARGET"; then
9400   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9401 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9402   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9403 fi
9404
9405 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9406   for ncn_progname in gfortran; do
9407     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9408 set dummy ${ncn_progname}; ac_word=$2
9409 echo "$as_me:$LINENO: checking for $ac_word" >&5
9410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9411 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9412   echo $ECHO_N "(cached) $ECHO_C" >&6
9413 else
9414   if test -n "$GFORTRAN_FOR_TARGET"; then
9415   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9416 else
9417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9418 for as_dir in $PATH
9419 do
9420   IFS=$as_save_IFS
9421   test -z "$as_dir" && as_dir=.
9422   for ac_exec_ext in '' $ac_executable_extensions; do
9423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9424     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9426     break 2
9427   fi
9428 done
9429 done
9430
9431 fi
9432 fi
9433 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9434 if test -n "$GFORTRAN_FOR_TARGET"; then
9435   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9436 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9437 else
9438   echo "$as_me:$LINENO: result: no" >&5
9439 echo "${ECHO_T}no" >&6
9440 fi
9441
9442   done
9443 fi
9444
9445 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9446   for ncn_progname in gfortran; do
9447     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9448 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9449     if test -x $with_build_time_tools/${ncn_progname}; then
9450       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9451       echo "$as_me:$LINENO: result: yes" >&5
9452 echo "${ECHO_T}yes" >&6
9453       break
9454     else
9455       echo "$as_me:$LINENO: result: no" >&5
9456 echo "${ECHO_T}no" >&6
9457     fi
9458   done
9459 fi
9460
9461 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9462   for ncn_progname in gfortran; do
9463     if test -n "$ncn_target_tool_prefix"; then
9464       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9465 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9466 echo "$as_me:$LINENO: checking for $ac_word" >&5
9467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9468 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9469   echo $ECHO_N "(cached) $ECHO_C" >&6
9470 else
9471   if test -n "$GFORTRAN_FOR_TARGET"; then
9472   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9473 else
9474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9475 for as_dir in $PATH
9476 do
9477   IFS=$as_save_IFS
9478   test -z "$as_dir" && as_dir=.
9479   for ac_exec_ext in '' $ac_executable_extensions; do
9480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9481     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9483     break 2
9484   fi
9485 done
9486 done
9487
9488 fi
9489 fi
9490 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9491 if test -n "$GFORTRAN_FOR_TARGET"; then
9492   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9493 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9494 else
9495   echo "$as_me:$LINENO: result: no" >&5
9496 echo "${ECHO_T}no" >&6
9497 fi
9498
9499     fi
9500     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9501       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9502 set dummy ${ncn_progname}; ac_word=$2
9503 echo "$as_me:$LINENO: checking for $ac_word" >&5
9504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9505 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9506   echo $ECHO_N "(cached) $ECHO_C" >&6
9507 else
9508   if test -n "$GFORTRAN_FOR_TARGET"; then
9509   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9510 else
9511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9512 for as_dir in $PATH
9513 do
9514   IFS=$as_save_IFS
9515   test -z "$as_dir" && as_dir=.
9516   for ac_exec_ext in '' $ac_executable_extensions; do
9517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9518     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9520     break 2
9521   fi
9522 done
9523 done
9524
9525 fi
9526 fi
9527 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9528 if test -n "$GFORTRAN_FOR_TARGET"; then
9529   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9530 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9531 else
9532   echo "$as_me:$LINENO: result: no" >&5
9533 echo "${ECHO_T}no" >&6
9534 fi
9535
9536     fi
9537     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9538   done
9539 fi
9540
9541 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9542   set dummy gfortran
9543   if test $build = $target ; then
9544     GFORTRAN_FOR_TARGET="$2"
9545   else
9546     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9547   fi
9548 else
9549   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9550 fi
9551
9552
9553
9554 cat > conftest.c << \EOF
9555 #ifdef __GNUC__
9556   gcc_yay;
9557 #endif
9558 EOF
9559 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9560   have_gcc_for_target=yes
9561 else
9562   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9563   have_gcc_for_target=no
9564 fi
9565 rm conftest.c
9566
9567
9568
9569
9570 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9571   if test -n "$with_build_time_tools"; then
9572     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9573 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9574     if test -x $with_build_time_tools/ar; then
9575       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9576       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9577       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9578 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9579     else
9580       echo "$as_me:$LINENO: result: no" >&5
9581 echo "${ECHO_T}no" >&6
9582     fi
9583   elif test $build != $host && test $have_gcc_for_target = yes; then
9584     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9585     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9586     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9587   fi
9588 fi
9589 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9590   # Extract the first word of "ar", so it can be a program name with args.
9591 set dummy ar; ac_word=$2
9592 echo "$as_me:$LINENO: checking for $ac_word" >&5
9593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9594 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9595   echo $ECHO_N "(cached) $ECHO_C" >&6
9596 else
9597   case $AR_FOR_TARGET in
9598   [\\/]* | ?:[\\/]*)
9599   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9600   ;;
9601   *)
9602   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9603 for as_dir in $gcc_cv_tool_dirs
9604 do
9605   IFS=$as_save_IFS
9606   test -z "$as_dir" && as_dir=.
9607   for ac_exec_ext in '' $ac_executable_extensions; do
9608   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9609     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9610     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9611     break 2
9612   fi
9613 done
9614 done
9615
9616   ;;
9617 esac
9618 fi
9619 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9620
9621 if test -n "$AR_FOR_TARGET"; then
9622   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9623 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9624 else
9625   echo "$as_me:$LINENO: result: no" >&5
9626 echo "${ECHO_T}no" >&6
9627 fi
9628
9629 fi
9630 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9631
9632
9633 if test -n "$AR_FOR_TARGET"; then
9634   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9635 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9636   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9637 fi
9638
9639 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9640   for ncn_progname in ar; do
9641     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9642 set dummy ${ncn_progname}; ac_word=$2
9643 echo "$as_me:$LINENO: checking for $ac_word" >&5
9644 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9645 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9646   echo $ECHO_N "(cached) $ECHO_C" >&6
9647 else
9648   if test -n "$AR_FOR_TARGET"; then
9649   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9650 else
9651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9652 for as_dir in $PATH
9653 do
9654   IFS=$as_save_IFS
9655   test -z "$as_dir" && as_dir=.
9656   for ac_exec_ext in '' $ac_executable_extensions; do
9657   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9658     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9659     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9660     break 2
9661   fi
9662 done
9663 done
9664
9665 fi
9666 fi
9667 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9668 if test -n "$AR_FOR_TARGET"; then
9669   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9670 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9671 else
9672   echo "$as_me:$LINENO: result: no" >&5
9673 echo "${ECHO_T}no" >&6
9674 fi
9675
9676   done
9677 fi
9678
9679 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9680   for ncn_progname in ar; do
9681     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9682 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9683     if test -x $with_build_time_tools/${ncn_progname}; then
9684       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9685       echo "$as_me:$LINENO: result: yes" >&5
9686 echo "${ECHO_T}yes" >&6
9687       break
9688     else
9689       echo "$as_me:$LINENO: result: no" >&5
9690 echo "${ECHO_T}no" >&6
9691     fi
9692   done
9693 fi
9694
9695 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9696   for ncn_progname in ar; do
9697     if test -n "$ncn_target_tool_prefix"; then
9698       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9699 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9700 echo "$as_me:$LINENO: checking for $ac_word" >&5
9701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9702 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9703   echo $ECHO_N "(cached) $ECHO_C" >&6
9704 else
9705   if test -n "$AR_FOR_TARGET"; then
9706   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9707 else
9708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9709 for as_dir in $PATH
9710 do
9711   IFS=$as_save_IFS
9712   test -z "$as_dir" && as_dir=.
9713   for ac_exec_ext in '' $ac_executable_extensions; do
9714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9715     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9717     break 2
9718   fi
9719 done
9720 done
9721
9722 fi
9723 fi
9724 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9725 if test -n "$AR_FOR_TARGET"; then
9726   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9727 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9728 else
9729   echo "$as_me:$LINENO: result: no" >&5
9730 echo "${ECHO_T}no" >&6
9731 fi
9732
9733     fi
9734     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9735       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9736 set dummy ${ncn_progname}; ac_word=$2
9737 echo "$as_me:$LINENO: checking for $ac_word" >&5
9738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9739 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9740   echo $ECHO_N "(cached) $ECHO_C" >&6
9741 else
9742   if test -n "$AR_FOR_TARGET"; then
9743   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9744 else
9745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9746 for as_dir in $PATH
9747 do
9748   IFS=$as_save_IFS
9749   test -z "$as_dir" && as_dir=.
9750   for ac_exec_ext in '' $ac_executable_extensions; do
9751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9752     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9754     break 2
9755   fi
9756 done
9757 done
9758
9759 fi
9760 fi
9761 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9762 if test -n "$AR_FOR_TARGET"; then
9763   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9764 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9765 else
9766   echo "$as_me:$LINENO: result: no" >&5
9767 echo "${ECHO_T}no" >&6
9768 fi
9769
9770     fi
9771     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9772   done
9773 fi
9774
9775 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9776   set dummy ar
9777   if test $build = $target ; then
9778     AR_FOR_TARGET="$2"
9779   else
9780     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9781   fi
9782 else
9783   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9784 fi
9785
9786 else
9787   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9788 fi
9789
9790
9791
9792
9793 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9794   if test -n "$with_build_time_tools"; then
9795     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9796 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9797     if test -x $with_build_time_tools/as; then
9798       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9799       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9800       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9801 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9802     else
9803       echo "$as_me:$LINENO: result: no" >&5
9804 echo "${ECHO_T}no" >&6
9805     fi
9806   elif test $build != $host && test $have_gcc_for_target = yes; then
9807     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9808     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9809     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9810   fi
9811 fi
9812 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9813   # Extract the first word of "as", so it can be a program name with args.
9814 set dummy as; ac_word=$2
9815 echo "$as_me:$LINENO: checking for $ac_word" >&5
9816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9817 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9818   echo $ECHO_N "(cached) $ECHO_C" >&6
9819 else
9820   case $AS_FOR_TARGET in
9821   [\\/]* | ?:[\\/]*)
9822   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9823   ;;
9824   *)
9825   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9826 for as_dir in $gcc_cv_tool_dirs
9827 do
9828   IFS=$as_save_IFS
9829   test -z "$as_dir" && as_dir=.
9830   for ac_exec_ext in '' $ac_executable_extensions; do
9831   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9832     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9833     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9834     break 2
9835   fi
9836 done
9837 done
9838
9839   ;;
9840 esac
9841 fi
9842 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9843
9844 if test -n "$AS_FOR_TARGET"; then
9845   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9846 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9847 else
9848   echo "$as_me:$LINENO: result: no" >&5
9849 echo "${ECHO_T}no" >&6
9850 fi
9851
9852 fi
9853 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9854
9855
9856 if test -n "$AS_FOR_TARGET"; then
9857   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9858 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9859   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9860 fi
9861
9862 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9863   for ncn_progname in as; do
9864     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9865 set dummy ${ncn_progname}; ac_word=$2
9866 echo "$as_me:$LINENO: checking for $ac_word" >&5
9867 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9868 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9869   echo $ECHO_N "(cached) $ECHO_C" >&6
9870 else
9871   if test -n "$AS_FOR_TARGET"; then
9872   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9873 else
9874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9875 for as_dir in $PATH
9876 do
9877   IFS=$as_save_IFS
9878   test -z "$as_dir" && as_dir=.
9879   for ac_exec_ext in '' $ac_executable_extensions; do
9880   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9881     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9882     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9883     break 2
9884   fi
9885 done
9886 done
9887
9888 fi
9889 fi
9890 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9891 if test -n "$AS_FOR_TARGET"; then
9892   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9893 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9894 else
9895   echo "$as_me:$LINENO: result: no" >&5
9896 echo "${ECHO_T}no" >&6
9897 fi
9898
9899   done
9900 fi
9901
9902 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9903   for ncn_progname in as; do
9904     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9905 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9906     if test -x $with_build_time_tools/${ncn_progname}; then
9907       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9908       echo "$as_me:$LINENO: result: yes" >&5
9909 echo "${ECHO_T}yes" >&6
9910       break
9911     else
9912       echo "$as_me:$LINENO: result: no" >&5
9913 echo "${ECHO_T}no" >&6
9914     fi
9915   done
9916 fi
9917
9918 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9919   for ncn_progname in as; do
9920     if test -n "$ncn_target_tool_prefix"; then
9921       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9922 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9923 echo "$as_me:$LINENO: checking for $ac_word" >&5
9924 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9925 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9926   echo $ECHO_N "(cached) $ECHO_C" >&6
9927 else
9928   if test -n "$AS_FOR_TARGET"; then
9929   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9930 else
9931 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9932 for as_dir in $PATH
9933 do
9934   IFS=$as_save_IFS
9935   test -z "$as_dir" && as_dir=.
9936   for ac_exec_ext in '' $ac_executable_extensions; do
9937   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9938     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9939     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9940     break 2
9941   fi
9942 done
9943 done
9944
9945 fi
9946 fi
9947 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9948 if test -n "$AS_FOR_TARGET"; then
9949   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9950 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9951 else
9952   echo "$as_me:$LINENO: result: no" >&5
9953 echo "${ECHO_T}no" >&6
9954 fi
9955
9956     fi
9957     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9958       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9959 set dummy ${ncn_progname}; ac_word=$2
9960 echo "$as_me:$LINENO: checking for $ac_word" >&5
9961 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9962 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9963   echo $ECHO_N "(cached) $ECHO_C" >&6
9964 else
9965   if test -n "$AS_FOR_TARGET"; then
9966   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9967 else
9968 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9969 for as_dir in $PATH
9970 do
9971   IFS=$as_save_IFS
9972   test -z "$as_dir" && as_dir=.
9973   for ac_exec_ext in '' $ac_executable_extensions; do
9974   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9975     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9976     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9977     break 2
9978   fi
9979 done
9980 done
9981
9982 fi
9983 fi
9984 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9985 if test -n "$AS_FOR_TARGET"; then
9986   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9987 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9988 else
9989   echo "$as_me:$LINENO: result: no" >&5
9990 echo "${ECHO_T}no" >&6
9991 fi
9992
9993     fi
9994     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9995   done
9996 fi
9997
9998 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9999   set dummy as
10000   if test $build = $target ; then
10001     AS_FOR_TARGET="$2"
10002   else
10003     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
10004   fi
10005 else
10006   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
10007 fi
10008
10009 else
10010   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
10011 fi
10012
10013
10014
10015
10016 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10017   if test -n "$with_build_time_tools"; then
10018     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
10019 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
10020     if test -x $with_build_time_tools/dlltool; then
10021       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
10022       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10023       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
10024 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
10025     else
10026       echo "$as_me:$LINENO: result: no" >&5
10027 echo "${ECHO_T}no" >&6
10028     fi
10029   elif test $build != $host && test $have_gcc_for_target = yes; then
10030     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
10031     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
10032     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10033   fi
10034 fi
10035 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10036   # Extract the first word of "dlltool", so it can be a program name with args.
10037 set dummy dlltool; ac_word=$2
10038 echo "$as_me:$LINENO: checking for $ac_word" >&5
10039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10040 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
10041   echo $ECHO_N "(cached) $ECHO_C" >&6
10042 else
10043   case $DLLTOOL_FOR_TARGET in
10044   [\\/]* | ?:[\\/]*)
10045   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
10046   ;;
10047   *)
10048   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10049 for as_dir in $gcc_cv_tool_dirs
10050 do
10051   IFS=$as_save_IFS
10052   test -z "$as_dir" && as_dir=.
10053   for ac_exec_ext in '' $ac_executable_extensions; do
10054   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10055     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10056     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10057     break 2
10058   fi
10059 done
10060 done
10061
10062   ;;
10063 esac
10064 fi
10065 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10066
10067 if test -n "$DLLTOOL_FOR_TARGET"; then
10068   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10069 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10070 else
10071   echo "$as_me:$LINENO: result: no" >&5
10072 echo "${ECHO_T}no" >&6
10073 fi
10074
10075 fi
10076 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10077
10078
10079 if test -n "$DLLTOOL_FOR_TARGET"; then
10080   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10081 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10082   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10083 fi
10084
10085 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10086   for ncn_progname in dlltool; do
10087     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10088 set dummy ${ncn_progname}; ac_word=$2
10089 echo "$as_me:$LINENO: checking for $ac_word" >&5
10090 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10091 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10092   echo $ECHO_N "(cached) $ECHO_C" >&6
10093 else
10094   if test -n "$DLLTOOL_FOR_TARGET"; then
10095   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10096 else
10097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10098 for as_dir in $PATH
10099 do
10100   IFS=$as_save_IFS
10101   test -z "$as_dir" && as_dir=.
10102   for ac_exec_ext in '' $ac_executable_extensions; do
10103   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10104     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10105     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10106     break 2
10107   fi
10108 done
10109 done
10110
10111 fi
10112 fi
10113 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10114 if test -n "$DLLTOOL_FOR_TARGET"; then
10115   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10116 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10117 else
10118   echo "$as_me:$LINENO: result: no" >&5
10119 echo "${ECHO_T}no" >&6
10120 fi
10121
10122   done
10123 fi
10124
10125 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10126   for ncn_progname in dlltool; do
10127     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10128 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10129     if test -x $with_build_time_tools/${ncn_progname}; then
10130       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10131       echo "$as_me:$LINENO: result: yes" >&5
10132 echo "${ECHO_T}yes" >&6
10133       break
10134     else
10135       echo "$as_me:$LINENO: result: no" >&5
10136 echo "${ECHO_T}no" >&6
10137     fi
10138   done
10139 fi
10140
10141 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10142   for ncn_progname in dlltool; do
10143     if test -n "$ncn_target_tool_prefix"; then
10144       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10145 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10146 echo "$as_me:$LINENO: checking for $ac_word" >&5
10147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10148 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10149   echo $ECHO_N "(cached) $ECHO_C" >&6
10150 else
10151   if test -n "$DLLTOOL_FOR_TARGET"; then
10152   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10153 else
10154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10155 for as_dir in $PATH
10156 do
10157   IFS=$as_save_IFS
10158   test -z "$as_dir" && as_dir=.
10159   for ac_exec_ext in '' $ac_executable_extensions; do
10160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10161     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10163     break 2
10164   fi
10165 done
10166 done
10167
10168 fi
10169 fi
10170 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10171 if test -n "$DLLTOOL_FOR_TARGET"; then
10172   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10173 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10174 else
10175   echo "$as_me:$LINENO: result: no" >&5
10176 echo "${ECHO_T}no" >&6
10177 fi
10178
10179     fi
10180     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10181       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10182 set dummy ${ncn_progname}; ac_word=$2
10183 echo "$as_me:$LINENO: checking for $ac_word" >&5
10184 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10185 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10186   echo $ECHO_N "(cached) $ECHO_C" >&6
10187 else
10188   if test -n "$DLLTOOL_FOR_TARGET"; then
10189   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10190 else
10191 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10192 for as_dir in $PATH
10193 do
10194   IFS=$as_save_IFS
10195   test -z "$as_dir" && as_dir=.
10196   for ac_exec_ext in '' $ac_executable_extensions; do
10197   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10198     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10199     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10200     break 2
10201   fi
10202 done
10203 done
10204
10205 fi
10206 fi
10207 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10208 if test -n "$DLLTOOL_FOR_TARGET"; then
10209   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10210 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10211 else
10212   echo "$as_me:$LINENO: result: no" >&5
10213 echo "${ECHO_T}no" >&6
10214 fi
10215
10216     fi
10217     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10218   done
10219 fi
10220
10221 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10222   set dummy dlltool
10223   if test $build = $target ; then
10224     DLLTOOL_FOR_TARGET="$2"
10225   else
10226     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10227   fi
10228 else
10229   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10230 fi
10231
10232 else
10233   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10234 fi
10235
10236
10237
10238
10239 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10240   if test -n "$with_build_time_tools"; then
10241     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10242 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10243     if test -x $with_build_time_tools/ld; then
10244       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10245       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10246       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10247 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10248     else
10249       echo "$as_me:$LINENO: result: no" >&5
10250 echo "${ECHO_T}no" >&6
10251     fi
10252   elif test $build != $host && test $have_gcc_for_target = yes; then
10253     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10254     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10255     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10256   fi
10257 fi
10258 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10259   # Extract the first word of "ld", so it can be a program name with args.
10260 set dummy ld; ac_word=$2
10261 echo "$as_me:$LINENO: checking for $ac_word" >&5
10262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10263 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10264   echo $ECHO_N "(cached) $ECHO_C" >&6
10265 else
10266   case $LD_FOR_TARGET in
10267   [\\/]* | ?:[\\/]*)
10268   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10269   ;;
10270   *)
10271   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10272 for as_dir in $gcc_cv_tool_dirs
10273 do
10274   IFS=$as_save_IFS
10275   test -z "$as_dir" && as_dir=.
10276   for ac_exec_ext in '' $ac_executable_extensions; do
10277   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10278     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10279     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10280     break 2
10281   fi
10282 done
10283 done
10284
10285   ;;
10286 esac
10287 fi
10288 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10289
10290 if test -n "$LD_FOR_TARGET"; then
10291   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10292 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10293 else
10294   echo "$as_me:$LINENO: result: no" >&5
10295 echo "${ECHO_T}no" >&6
10296 fi
10297
10298 fi
10299 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10300
10301
10302 if test -n "$LD_FOR_TARGET"; then
10303   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10304 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10305   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10306 fi
10307
10308 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10309   for ncn_progname in ld; do
10310     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10311 set dummy ${ncn_progname}; ac_word=$2
10312 echo "$as_me:$LINENO: checking for $ac_word" >&5
10313 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10314 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10315   echo $ECHO_N "(cached) $ECHO_C" >&6
10316 else
10317   if test -n "$LD_FOR_TARGET"; then
10318   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10319 else
10320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10321 for as_dir in $PATH
10322 do
10323   IFS=$as_save_IFS
10324   test -z "$as_dir" && as_dir=.
10325   for ac_exec_ext in '' $ac_executable_extensions; do
10326   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10327     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10328     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10329     break 2
10330   fi
10331 done
10332 done
10333
10334 fi
10335 fi
10336 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10337 if test -n "$LD_FOR_TARGET"; then
10338   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10339 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10340 else
10341   echo "$as_me:$LINENO: result: no" >&5
10342 echo "${ECHO_T}no" >&6
10343 fi
10344
10345   done
10346 fi
10347
10348 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10349   for ncn_progname in ld; do
10350     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10351 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10352     if test -x $with_build_time_tools/${ncn_progname}; then
10353       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10354       echo "$as_me:$LINENO: result: yes" >&5
10355 echo "${ECHO_T}yes" >&6
10356       break
10357     else
10358       echo "$as_me:$LINENO: result: no" >&5
10359 echo "${ECHO_T}no" >&6
10360     fi
10361   done
10362 fi
10363
10364 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10365   for ncn_progname in ld; do
10366     if test -n "$ncn_target_tool_prefix"; then
10367       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10368 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10369 echo "$as_me:$LINENO: checking for $ac_word" >&5
10370 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10371 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10372   echo $ECHO_N "(cached) $ECHO_C" >&6
10373 else
10374   if test -n "$LD_FOR_TARGET"; then
10375   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10376 else
10377 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10378 for as_dir in $PATH
10379 do
10380   IFS=$as_save_IFS
10381   test -z "$as_dir" && as_dir=.
10382   for ac_exec_ext in '' $ac_executable_extensions; do
10383   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10384     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10385     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10386     break 2
10387   fi
10388 done
10389 done
10390
10391 fi
10392 fi
10393 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10394 if test -n "$LD_FOR_TARGET"; then
10395   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10396 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10397 else
10398   echo "$as_me:$LINENO: result: no" >&5
10399 echo "${ECHO_T}no" >&6
10400 fi
10401
10402     fi
10403     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10404       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10405 set dummy ${ncn_progname}; ac_word=$2
10406 echo "$as_me:$LINENO: checking for $ac_word" >&5
10407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10408 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10409   echo $ECHO_N "(cached) $ECHO_C" >&6
10410 else
10411   if test -n "$LD_FOR_TARGET"; then
10412   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10413 else
10414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10415 for as_dir in $PATH
10416 do
10417   IFS=$as_save_IFS
10418   test -z "$as_dir" && as_dir=.
10419   for ac_exec_ext in '' $ac_executable_extensions; do
10420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10421     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10423     break 2
10424   fi
10425 done
10426 done
10427
10428 fi
10429 fi
10430 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10431 if test -n "$LD_FOR_TARGET"; then
10432   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10433 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10434 else
10435   echo "$as_me:$LINENO: result: no" >&5
10436 echo "${ECHO_T}no" >&6
10437 fi
10438
10439     fi
10440     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10441   done
10442 fi
10443
10444 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10445   set dummy ld
10446   if test $build = $target ; then
10447     LD_FOR_TARGET="$2"
10448   else
10449     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10450   fi
10451 else
10452   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10453 fi
10454
10455 else
10456   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10457 fi
10458
10459
10460
10461
10462 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10463   if test -n "$with_build_time_tools"; then
10464     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10465 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10466     if test -x $with_build_time_tools/lipo; then
10467       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10468       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10469       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10470 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10471     else
10472       echo "$as_me:$LINENO: result: no" >&5
10473 echo "${ECHO_T}no" >&6
10474     fi
10475   elif test $build != $host && test $have_gcc_for_target = yes; then
10476     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10477     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10478     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10479   fi
10480 fi
10481 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10482   # Extract the first word of "lipo", so it can be a program name with args.
10483 set dummy lipo; ac_word=$2
10484 echo "$as_me:$LINENO: checking for $ac_word" >&5
10485 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10486 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10487   echo $ECHO_N "(cached) $ECHO_C" >&6
10488 else
10489   case $LIPO_FOR_TARGET in
10490   [\\/]* | ?:[\\/]*)
10491   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10492   ;;
10493   *)
10494   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10495 for as_dir in $gcc_cv_tool_dirs
10496 do
10497   IFS=$as_save_IFS
10498   test -z "$as_dir" && as_dir=.
10499   for ac_exec_ext in '' $ac_executable_extensions; do
10500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10501     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10503     break 2
10504   fi
10505 done
10506 done
10507
10508   ;;
10509 esac
10510 fi
10511 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10512
10513 if test -n "$LIPO_FOR_TARGET"; then
10514   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10515 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10516 else
10517   echo "$as_me:$LINENO: result: no" >&5
10518 echo "${ECHO_T}no" >&6
10519 fi
10520
10521 fi
10522 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10523
10524
10525 if test -n "$LIPO_FOR_TARGET"; then
10526   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10527 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10528   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10529 fi
10530
10531 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10532   for ncn_progname in lipo; do
10533     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10534 set dummy ${ncn_progname}; ac_word=$2
10535 echo "$as_me:$LINENO: checking for $ac_word" >&5
10536 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10537 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10538   echo $ECHO_N "(cached) $ECHO_C" >&6
10539 else
10540   if test -n "$LIPO_FOR_TARGET"; then
10541   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10542 else
10543 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10544 for as_dir in $PATH
10545 do
10546   IFS=$as_save_IFS
10547   test -z "$as_dir" && as_dir=.
10548   for ac_exec_ext in '' $ac_executable_extensions; do
10549   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10550     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10551     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10552     break 2
10553   fi
10554 done
10555 done
10556
10557 fi
10558 fi
10559 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10560 if test -n "$LIPO_FOR_TARGET"; then
10561   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10562 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10563 else
10564   echo "$as_me:$LINENO: result: no" >&5
10565 echo "${ECHO_T}no" >&6
10566 fi
10567
10568   done
10569 fi
10570
10571 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10572   for ncn_progname in lipo; do
10573     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10574 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10575     if test -x $with_build_time_tools/${ncn_progname}; then
10576       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10577       echo "$as_me:$LINENO: result: yes" >&5
10578 echo "${ECHO_T}yes" >&6
10579       break
10580     else
10581       echo "$as_me:$LINENO: result: no" >&5
10582 echo "${ECHO_T}no" >&6
10583     fi
10584   done
10585 fi
10586
10587 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10588   for ncn_progname in lipo; do
10589     if test -n "$ncn_target_tool_prefix"; then
10590       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10591 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10592 echo "$as_me:$LINENO: checking for $ac_word" >&5
10593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10594 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10595   echo $ECHO_N "(cached) $ECHO_C" >&6
10596 else
10597   if test -n "$LIPO_FOR_TARGET"; then
10598   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10599 else
10600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10601 for as_dir in $PATH
10602 do
10603   IFS=$as_save_IFS
10604   test -z "$as_dir" && as_dir=.
10605   for ac_exec_ext in '' $ac_executable_extensions; do
10606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10607     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10609     break 2
10610   fi
10611 done
10612 done
10613
10614 fi
10615 fi
10616 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10617 if test -n "$LIPO_FOR_TARGET"; then
10618   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10619 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10620 else
10621   echo "$as_me:$LINENO: result: no" >&5
10622 echo "${ECHO_T}no" >&6
10623 fi
10624
10625     fi
10626     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10627       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10628 set dummy ${ncn_progname}; ac_word=$2
10629 echo "$as_me:$LINENO: checking for $ac_word" >&5
10630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10631 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10632   echo $ECHO_N "(cached) $ECHO_C" >&6
10633 else
10634   if test -n "$LIPO_FOR_TARGET"; then
10635   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10636 else
10637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10638 for as_dir in $PATH
10639 do
10640   IFS=$as_save_IFS
10641   test -z "$as_dir" && as_dir=.
10642   for ac_exec_ext in '' $ac_executable_extensions; do
10643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10644     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10646     break 2
10647   fi
10648 done
10649 done
10650
10651 fi
10652 fi
10653 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10654 if test -n "$LIPO_FOR_TARGET"; then
10655   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10656 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10657 else
10658   echo "$as_me:$LINENO: result: no" >&5
10659 echo "${ECHO_T}no" >&6
10660 fi
10661
10662     fi
10663     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10664   done
10665 fi
10666
10667 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10668   set dummy lipo
10669   if test $build = $target ; then
10670     LIPO_FOR_TARGET="$2"
10671   else
10672     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10673   fi
10674 else
10675   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10676 fi
10677
10678 else
10679   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10680 fi
10681
10682
10683
10684
10685 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10686   if test -n "$with_build_time_tools"; then
10687     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10688 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10689     if test -x $with_build_time_tools/nm; then
10690       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10691       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10692       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10693 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10694     else
10695       echo "$as_me:$LINENO: result: no" >&5
10696 echo "${ECHO_T}no" >&6
10697     fi
10698   elif test $build != $host && test $have_gcc_for_target = yes; then
10699     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10700     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10701     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10702   fi
10703 fi
10704 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10705   # Extract the first word of "nm", so it can be a program name with args.
10706 set dummy nm; ac_word=$2
10707 echo "$as_me:$LINENO: checking for $ac_word" >&5
10708 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10709 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10710   echo $ECHO_N "(cached) $ECHO_C" >&6
10711 else
10712   case $NM_FOR_TARGET in
10713   [\\/]* | ?:[\\/]*)
10714   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10715   ;;
10716   *)
10717   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10718 for as_dir in $gcc_cv_tool_dirs
10719 do
10720   IFS=$as_save_IFS
10721   test -z "$as_dir" && as_dir=.
10722   for ac_exec_ext in '' $ac_executable_extensions; do
10723   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10724     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10725     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10726     break 2
10727   fi
10728 done
10729 done
10730
10731   ;;
10732 esac
10733 fi
10734 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10735
10736 if test -n "$NM_FOR_TARGET"; then
10737   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10738 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10739 else
10740   echo "$as_me:$LINENO: result: no" >&5
10741 echo "${ECHO_T}no" >&6
10742 fi
10743
10744 fi
10745 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10746
10747
10748 if test -n "$NM_FOR_TARGET"; then
10749   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10750 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10751   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10752 fi
10753
10754 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10755   for ncn_progname in nm; do
10756     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10757 set dummy ${ncn_progname}; ac_word=$2
10758 echo "$as_me:$LINENO: checking for $ac_word" >&5
10759 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10760 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10761   echo $ECHO_N "(cached) $ECHO_C" >&6
10762 else
10763   if test -n "$NM_FOR_TARGET"; then
10764   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10765 else
10766 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10767 for as_dir in $PATH
10768 do
10769   IFS=$as_save_IFS
10770   test -z "$as_dir" && as_dir=.
10771   for ac_exec_ext in '' $ac_executable_extensions; do
10772   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10773     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10774     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10775     break 2
10776   fi
10777 done
10778 done
10779
10780 fi
10781 fi
10782 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10783 if test -n "$NM_FOR_TARGET"; then
10784   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10785 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10786 else
10787   echo "$as_me:$LINENO: result: no" >&5
10788 echo "${ECHO_T}no" >&6
10789 fi
10790
10791   done
10792 fi
10793
10794 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10795   for ncn_progname in nm; do
10796     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10797 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10798     if test -x $with_build_time_tools/${ncn_progname}; then
10799       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10800       echo "$as_me:$LINENO: result: yes" >&5
10801 echo "${ECHO_T}yes" >&6
10802       break
10803     else
10804       echo "$as_me:$LINENO: result: no" >&5
10805 echo "${ECHO_T}no" >&6
10806     fi
10807   done
10808 fi
10809
10810 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10811   for ncn_progname in nm; do
10812     if test -n "$ncn_target_tool_prefix"; then
10813       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10814 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10815 echo "$as_me:$LINENO: checking for $ac_word" >&5
10816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10817 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10818   echo $ECHO_N "(cached) $ECHO_C" >&6
10819 else
10820   if test -n "$NM_FOR_TARGET"; then
10821   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10822 else
10823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10824 for as_dir in $PATH
10825 do
10826   IFS=$as_save_IFS
10827   test -z "$as_dir" && as_dir=.
10828   for ac_exec_ext in '' $ac_executable_extensions; do
10829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10830     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10832     break 2
10833   fi
10834 done
10835 done
10836
10837 fi
10838 fi
10839 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10840 if test -n "$NM_FOR_TARGET"; then
10841   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10842 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10843 else
10844   echo "$as_me:$LINENO: result: no" >&5
10845 echo "${ECHO_T}no" >&6
10846 fi
10847
10848     fi
10849     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10850       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10851 set dummy ${ncn_progname}; ac_word=$2
10852 echo "$as_me:$LINENO: checking for $ac_word" >&5
10853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10854 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10855   echo $ECHO_N "(cached) $ECHO_C" >&6
10856 else
10857   if test -n "$NM_FOR_TARGET"; then
10858   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10859 else
10860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10861 for as_dir in $PATH
10862 do
10863   IFS=$as_save_IFS
10864   test -z "$as_dir" && as_dir=.
10865   for ac_exec_ext in '' $ac_executable_extensions; do
10866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10867     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10869     break 2
10870   fi
10871 done
10872 done
10873
10874 fi
10875 fi
10876 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10877 if test -n "$NM_FOR_TARGET"; then
10878   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10879 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10880 else
10881   echo "$as_me:$LINENO: result: no" >&5
10882 echo "${ECHO_T}no" >&6
10883 fi
10884
10885     fi
10886     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10887   done
10888 fi
10889
10890 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10891   set dummy nm
10892   if test $build = $target ; then
10893     NM_FOR_TARGET="$2"
10894   else
10895     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10896   fi
10897 else
10898   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10899 fi
10900
10901 else
10902   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10903 fi
10904
10905
10906
10907
10908 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10909   if test -n "$with_build_time_tools"; then
10910     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10911 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10912     if test -x $with_build_time_tools/objdump; then
10913       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10914       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10915       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10916 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10917     else
10918       echo "$as_me:$LINENO: result: no" >&5
10919 echo "${ECHO_T}no" >&6
10920     fi
10921   elif test $build != $host && test $have_gcc_for_target = yes; then
10922     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10923     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10924     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10925   fi
10926 fi
10927 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10928   # Extract the first word of "objdump", so it can be a program name with args.
10929 set dummy objdump; ac_word=$2
10930 echo "$as_me:$LINENO: checking for $ac_word" >&5
10931 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10932 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10933   echo $ECHO_N "(cached) $ECHO_C" >&6
10934 else
10935   case $OBJDUMP_FOR_TARGET in
10936   [\\/]* | ?:[\\/]*)
10937   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10938   ;;
10939   *)
10940   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10941 for as_dir in $gcc_cv_tool_dirs
10942 do
10943   IFS=$as_save_IFS
10944   test -z "$as_dir" && as_dir=.
10945   for ac_exec_ext in '' $ac_executable_extensions; do
10946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10947     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10949     break 2
10950   fi
10951 done
10952 done
10953
10954   ;;
10955 esac
10956 fi
10957 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10958
10959 if test -n "$OBJDUMP_FOR_TARGET"; then
10960   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10961 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10962 else
10963   echo "$as_me:$LINENO: result: no" >&5
10964 echo "${ECHO_T}no" >&6
10965 fi
10966
10967 fi
10968 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10969
10970
10971 if test -n "$OBJDUMP_FOR_TARGET"; then
10972   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10973 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10974   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10975 fi
10976
10977 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10978   for ncn_progname in objdump; do
10979     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10980 set dummy ${ncn_progname}; ac_word=$2
10981 echo "$as_me:$LINENO: checking for $ac_word" >&5
10982 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10983 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10984   echo $ECHO_N "(cached) $ECHO_C" >&6
10985 else
10986   if test -n "$OBJDUMP_FOR_TARGET"; then
10987   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10988 else
10989 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10990 for as_dir in $PATH
10991 do
10992   IFS=$as_save_IFS
10993   test -z "$as_dir" && as_dir=.
10994   for ac_exec_ext in '' $ac_executable_extensions; do
10995   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10996     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10997     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10998     break 2
10999   fi
11000 done
11001 done
11002
11003 fi
11004 fi
11005 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11006 if test -n "$OBJDUMP_FOR_TARGET"; then
11007   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11008 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11009 else
11010   echo "$as_me:$LINENO: result: no" >&5
11011 echo "${ECHO_T}no" >&6
11012 fi
11013
11014   done
11015 fi
11016
11017 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11018   for ncn_progname in objdump; do
11019     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11020 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11021     if test -x $with_build_time_tools/${ncn_progname}; then
11022       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11023       echo "$as_me:$LINENO: result: yes" >&5
11024 echo "${ECHO_T}yes" >&6
11025       break
11026     else
11027       echo "$as_me:$LINENO: result: no" >&5
11028 echo "${ECHO_T}no" >&6
11029     fi
11030   done
11031 fi
11032
11033 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
11034   for ncn_progname in objdump; do
11035     if test -n "$ncn_target_tool_prefix"; then
11036       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11037 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11038 echo "$as_me:$LINENO: checking for $ac_word" >&5
11039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11040 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11041   echo $ECHO_N "(cached) $ECHO_C" >&6
11042 else
11043   if test -n "$OBJDUMP_FOR_TARGET"; then
11044   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11045 else
11046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11047 for as_dir in $PATH
11048 do
11049   IFS=$as_save_IFS
11050   test -z "$as_dir" && as_dir=.
11051   for ac_exec_ext in '' $ac_executable_extensions; do
11052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11053     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11055     break 2
11056   fi
11057 done
11058 done
11059
11060 fi
11061 fi
11062 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11063 if test -n "$OBJDUMP_FOR_TARGET"; then
11064   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11065 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11066 else
11067   echo "$as_me:$LINENO: result: no" >&5
11068 echo "${ECHO_T}no" >&6
11069 fi
11070
11071     fi
11072     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
11073       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11074 set dummy ${ncn_progname}; ac_word=$2
11075 echo "$as_me:$LINENO: checking for $ac_word" >&5
11076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11077 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11078   echo $ECHO_N "(cached) $ECHO_C" >&6
11079 else
11080   if test -n "$OBJDUMP_FOR_TARGET"; then
11081   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11082 else
11083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11084 for as_dir in $PATH
11085 do
11086   IFS=$as_save_IFS
11087   test -z "$as_dir" && as_dir=.
11088   for ac_exec_ext in '' $ac_executable_extensions; do
11089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11090     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
11091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11092     break 2
11093   fi
11094 done
11095 done
11096
11097 fi
11098 fi
11099 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11100 if test -n "$OBJDUMP_FOR_TARGET"; then
11101   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11102 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11103 else
11104   echo "$as_me:$LINENO: result: no" >&5
11105 echo "${ECHO_T}no" >&6
11106 fi
11107
11108     fi
11109     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11110   done
11111 fi
11112
11113 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11114   set dummy objdump
11115   if test $build = $target ; then
11116     OBJDUMP_FOR_TARGET="$2"
11117   else
11118     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11119   fi
11120 else
11121   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11122 fi
11123
11124 else
11125   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11126 fi
11127
11128
11129
11130
11131 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11132   if test -n "$with_build_time_tools"; then
11133     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11134 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11135     if test -x $with_build_time_tools/ranlib; then
11136       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11137       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11138       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11139 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11140     else
11141       echo "$as_me:$LINENO: result: no" >&5
11142 echo "${ECHO_T}no" >&6
11143     fi
11144   elif test $build != $host && test $have_gcc_for_target = yes; then
11145     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11146     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11147     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11148   fi
11149 fi
11150 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11151   # Extract the first word of "ranlib", so it can be a program name with args.
11152 set dummy ranlib; ac_word=$2
11153 echo "$as_me:$LINENO: checking for $ac_word" >&5
11154 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11155 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11156   echo $ECHO_N "(cached) $ECHO_C" >&6
11157 else
11158   case $RANLIB_FOR_TARGET in
11159   [\\/]* | ?:[\\/]*)
11160   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11161   ;;
11162   *)
11163   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11164 for as_dir in $gcc_cv_tool_dirs
11165 do
11166   IFS=$as_save_IFS
11167   test -z "$as_dir" && as_dir=.
11168   for ac_exec_ext in '' $ac_executable_extensions; do
11169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11170     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11172     break 2
11173   fi
11174 done
11175 done
11176
11177   ;;
11178 esac
11179 fi
11180 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11181
11182 if test -n "$RANLIB_FOR_TARGET"; then
11183   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11184 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11185 else
11186   echo "$as_me:$LINENO: result: no" >&5
11187 echo "${ECHO_T}no" >&6
11188 fi
11189
11190 fi
11191 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11192
11193
11194 if test -n "$RANLIB_FOR_TARGET"; then
11195   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11196 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11197   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11198 fi
11199
11200 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11201   for ncn_progname in ranlib; do
11202     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11203 set dummy ${ncn_progname}; ac_word=$2
11204 echo "$as_me:$LINENO: checking for $ac_word" >&5
11205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11206 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11207   echo $ECHO_N "(cached) $ECHO_C" >&6
11208 else
11209   if test -n "$RANLIB_FOR_TARGET"; then
11210   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11211 else
11212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11213 for as_dir in $PATH
11214 do
11215   IFS=$as_save_IFS
11216   test -z "$as_dir" && as_dir=.
11217   for ac_exec_ext in '' $ac_executable_extensions; do
11218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11219     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11221     break 2
11222   fi
11223 done
11224 done
11225
11226 fi
11227 fi
11228 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11229 if test -n "$RANLIB_FOR_TARGET"; then
11230   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11231 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11232 else
11233   echo "$as_me:$LINENO: result: no" >&5
11234 echo "${ECHO_T}no" >&6
11235 fi
11236
11237   done
11238 fi
11239
11240 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11241   for ncn_progname in ranlib; do
11242     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11243 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11244     if test -x $with_build_time_tools/${ncn_progname}; then
11245       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11246       echo "$as_me:$LINENO: result: yes" >&5
11247 echo "${ECHO_T}yes" >&6
11248       break
11249     else
11250       echo "$as_me:$LINENO: result: no" >&5
11251 echo "${ECHO_T}no" >&6
11252     fi
11253   done
11254 fi
11255
11256 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11257   for ncn_progname in ranlib; do
11258     if test -n "$ncn_target_tool_prefix"; then
11259       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11260 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11261 echo "$as_me:$LINENO: checking for $ac_word" >&5
11262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11263 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11264   echo $ECHO_N "(cached) $ECHO_C" >&6
11265 else
11266   if test -n "$RANLIB_FOR_TARGET"; then
11267   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11268 else
11269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11270 for as_dir in $PATH
11271 do
11272   IFS=$as_save_IFS
11273   test -z "$as_dir" && as_dir=.
11274   for ac_exec_ext in '' $ac_executable_extensions; do
11275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11276     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11278     break 2
11279   fi
11280 done
11281 done
11282
11283 fi
11284 fi
11285 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11286 if test -n "$RANLIB_FOR_TARGET"; then
11287   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11288 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11289 else
11290   echo "$as_me:$LINENO: result: no" >&5
11291 echo "${ECHO_T}no" >&6
11292 fi
11293
11294     fi
11295     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11296       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11297 set dummy ${ncn_progname}; ac_word=$2
11298 echo "$as_me:$LINENO: checking for $ac_word" >&5
11299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11300 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11301   echo $ECHO_N "(cached) $ECHO_C" >&6
11302 else
11303   if test -n "$RANLIB_FOR_TARGET"; then
11304   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11305 else
11306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11307 for as_dir in $PATH
11308 do
11309   IFS=$as_save_IFS
11310   test -z "$as_dir" && as_dir=.
11311   for ac_exec_ext in '' $ac_executable_extensions; do
11312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11313     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11315     break 2
11316   fi
11317 done
11318 done
11319
11320 fi
11321 fi
11322 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11323 if test -n "$RANLIB_FOR_TARGET"; then
11324   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11325 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11326 else
11327   echo "$as_me:$LINENO: result: no" >&5
11328 echo "${ECHO_T}no" >&6
11329 fi
11330
11331     fi
11332     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11333   done
11334 fi
11335
11336 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11337   set dummy ranlib
11338   if test $build = $target ; then
11339     RANLIB_FOR_TARGET="$2"
11340   else
11341     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11342   fi
11343 else
11344   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11345 fi
11346
11347 else
11348   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11349 fi
11350
11351
11352
11353
11354 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11355   if test -n "$with_build_time_tools"; then
11356     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11357 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11358     if test -x $with_build_time_tools/strip; then
11359       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11360       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11361       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11362 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11363     else
11364       echo "$as_me:$LINENO: result: no" >&5
11365 echo "${ECHO_T}no" >&6
11366     fi
11367   elif test $build != $host && test $have_gcc_for_target = yes; then
11368     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11369     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11370     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11371   fi
11372 fi
11373 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11374   # Extract the first word of "strip", so it can be a program name with args.
11375 set dummy strip; ac_word=$2
11376 echo "$as_me:$LINENO: checking for $ac_word" >&5
11377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11378 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11379   echo $ECHO_N "(cached) $ECHO_C" >&6
11380 else
11381   case $STRIP_FOR_TARGET in
11382   [\\/]* | ?:[\\/]*)
11383   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11384   ;;
11385   *)
11386   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11387 for as_dir in $gcc_cv_tool_dirs
11388 do
11389   IFS=$as_save_IFS
11390   test -z "$as_dir" && as_dir=.
11391   for ac_exec_ext in '' $ac_executable_extensions; do
11392   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11393     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11394     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11395     break 2
11396   fi
11397 done
11398 done
11399
11400   ;;
11401 esac
11402 fi
11403 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11404
11405 if test -n "$STRIP_FOR_TARGET"; then
11406   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11407 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11408 else
11409   echo "$as_me:$LINENO: result: no" >&5
11410 echo "${ECHO_T}no" >&6
11411 fi
11412
11413 fi
11414 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11415
11416
11417 if test -n "$STRIP_FOR_TARGET"; then
11418   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11419 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11420   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11421 fi
11422
11423 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11424   for ncn_progname in strip; do
11425     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11426 set dummy ${ncn_progname}; ac_word=$2
11427 echo "$as_me:$LINENO: checking for $ac_word" >&5
11428 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11429 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11430   echo $ECHO_N "(cached) $ECHO_C" >&6
11431 else
11432   if test -n "$STRIP_FOR_TARGET"; then
11433   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11434 else
11435 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11436 for as_dir in $PATH
11437 do
11438   IFS=$as_save_IFS
11439   test -z "$as_dir" && as_dir=.
11440   for ac_exec_ext in '' $ac_executable_extensions; do
11441   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11442     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11443     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11444     break 2
11445   fi
11446 done
11447 done
11448
11449 fi
11450 fi
11451 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11452 if test -n "$STRIP_FOR_TARGET"; then
11453   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11454 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11455 else
11456   echo "$as_me:$LINENO: result: no" >&5
11457 echo "${ECHO_T}no" >&6
11458 fi
11459
11460   done
11461 fi
11462
11463 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11464   for ncn_progname in strip; do
11465     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11466 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11467     if test -x $with_build_time_tools/${ncn_progname}; then
11468       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11469       echo "$as_me:$LINENO: result: yes" >&5
11470 echo "${ECHO_T}yes" >&6
11471       break
11472     else
11473       echo "$as_me:$LINENO: result: no" >&5
11474 echo "${ECHO_T}no" >&6
11475     fi
11476   done
11477 fi
11478
11479 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11480   for ncn_progname in strip; do
11481     if test -n "$ncn_target_tool_prefix"; then
11482       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11483 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11484 echo "$as_me:$LINENO: checking for $ac_word" >&5
11485 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11486 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11487   echo $ECHO_N "(cached) $ECHO_C" >&6
11488 else
11489   if test -n "$STRIP_FOR_TARGET"; then
11490   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11491 else
11492 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11493 for as_dir in $PATH
11494 do
11495   IFS=$as_save_IFS
11496   test -z "$as_dir" && as_dir=.
11497   for ac_exec_ext in '' $ac_executable_extensions; do
11498   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11499     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11500     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11501     break 2
11502   fi
11503 done
11504 done
11505
11506 fi
11507 fi
11508 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11509 if test -n "$STRIP_FOR_TARGET"; then
11510   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11511 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11512 else
11513   echo "$as_me:$LINENO: result: no" >&5
11514 echo "${ECHO_T}no" >&6
11515 fi
11516
11517     fi
11518     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11519       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11520 set dummy ${ncn_progname}; ac_word=$2
11521 echo "$as_me:$LINENO: checking for $ac_word" >&5
11522 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11523 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11524   echo $ECHO_N "(cached) $ECHO_C" >&6
11525 else
11526   if test -n "$STRIP_FOR_TARGET"; then
11527   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11528 else
11529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11530 for as_dir in $PATH
11531 do
11532   IFS=$as_save_IFS
11533   test -z "$as_dir" && as_dir=.
11534   for ac_exec_ext in '' $ac_executable_extensions; do
11535   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11536     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11537     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11538     break 2
11539   fi
11540 done
11541 done
11542
11543 fi
11544 fi
11545 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11546 if test -n "$STRIP_FOR_TARGET"; then
11547   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11548 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11549 else
11550   echo "$as_me:$LINENO: result: no" >&5
11551 echo "${ECHO_T}no" >&6
11552 fi
11553
11554     fi
11555     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11556   done
11557 fi
11558
11559 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11560   set dummy strip
11561   if test $build = $target ; then
11562     STRIP_FOR_TARGET="$2"
11563   else
11564     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11565   fi
11566 else
11567   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11568 fi
11569
11570 else
11571   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11572 fi
11573
11574
11575
11576
11577 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11578   if test -n "$with_build_time_tools"; then
11579     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11580 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11581     if test -x $with_build_time_tools/windres; then
11582       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11583       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11584       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11585 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11586     else
11587       echo "$as_me:$LINENO: result: no" >&5
11588 echo "${ECHO_T}no" >&6
11589     fi
11590   elif test $build != $host && test $have_gcc_for_target = yes; then
11591     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11592     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11593     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11594   fi
11595 fi
11596 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11597   # Extract the first word of "windres", so it can be a program name with args.
11598 set dummy windres; ac_word=$2
11599 echo "$as_me:$LINENO: checking for $ac_word" >&5
11600 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11601 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11602   echo $ECHO_N "(cached) $ECHO_C" >&6
11603 else
11604   case $WINDRES_FOR_TARGET in
11605   [\\/]* | ?:[\\/]*)
11606   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11607   ;;
11608   *)
11609   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11610 for as_dir in $gcc_cv_tool_dirs
11611 do
11612   IFS=$as_save_IFS
11613   test -z "$as_dir" && as_dir=.
11614   for ac_exec_ext in '' $ac_executable_extensions; do
11615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11616     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11618     break 2
11619   fi
11620 done
11621 done
11622
11623   ;;
11624 esac
11625 fi
11626 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11627
11628 if test -n "$WINDRES_FOR_TARGET"; then
11629   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11630 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11631 else
11632   echo "$as_me:$LINENO: result: no" >&5
11633 echo "${ECHO_T}no" >&6
11634 fi
11635
11636 fi
11637 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11638
11639
11640 if test -n "$WINDRES_FOR_TARGET"; then
11641   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11642 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11643   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11644 fi
11645
11646 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11647   for ncn_progname in windres; do
11648     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11649 set dummy ${ncn_progname}; ac_word=$2
11650 echo "$as_me:$LINENO: checking for $ac_word" >&5
11651 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11652 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11653   echo $ECHO_N "(cached) $ECHO_C" >&6
11654 else
11655   if test -n "$WINDRES_FOR_TARGET"; then
11656   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11657 else
11658 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11659 for as_dir in $PATH
11660 do
11661   IFS=$as_save_IFS
11662   test -z "$as_dir" && as_dir=.
11663   for ac_exec_ext in '' $ac_executable_extensions; do
11664   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11665     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11666     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11667     break 2
11668   fi
11669 done
11670 done
11671
11672 fi
11673 fi
11674 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11675 if test -n "$WINDRES_FOR_TARGET"; then
11676   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11677 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11678 else
11679   echo "$as_me:$LINENO: result: no" >&5
11680 echo "${ECHO_T}no" >&6
11681 fi
11682
11683   done
11684 fi
11685
11686 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11687   for ncn_progname in windres; do
11688     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11689 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11690     if test -x $with_build_time_tools/${ncn_progname}; then
11691       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11692       echo "$as_me:$LINENO: result: yes" >&5
11693 echo "${ECHO_T}yes" >&6
11694       break
11695     else
11696       echo "$as_me:$LINENO: result: no" >&5
11697 echo "${ECHO_T}no" >&6
11698     fi
11699   done
11700 fi
11701
11702 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11703   for ncn_progname in windres; do
11704     if test -n "$ncn_target_tool_prefix"; then
11705       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11706 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11707 echo "$as_me:$LINENO: checking for $ac_word" >&5
11708 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11709 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11710   echo $ECHO_N "(cached) $ECHO_C" >&6
11711 else
11712   if test -n "$WINDRES_FOR_TARGET"; then
11713   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11714 else
11715 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11716 for as_dir in $PATH
11717 do
11718   IFS=$as_save_IFS
11719   test -z "$as_dir" && as_dir=.
11720   for ac_exec_ext in '' $ac_executable_extensions; do
11721   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11722     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11723     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11724     break 2
11725   fi
11726 done
11727 done
11728
11729 fi
11730 fi
11731 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11732 if test -n "$WINDRES_FOR_TARGET"; then
11733   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11734 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11735 else
11736   echo "$as_me:$LINENO: result: no" >&5
11737 echo "${ECHO_T}no" >&6
11738 fi
11739
11740     fi
11741     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11742       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11743 set dummy ${ncn_progname}; ac_word=$2
11744 echo "$as_me:$LINENO: checking for $ac_word" >&5
11745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11746 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11747   echo $ECHO_N "(cached) $ECHO_C" >&6
11748 else
11749   if test -n "$WINDRES_FOR_TARGET"; then
11750   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11751 else
11752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11753 for as_dir in $PATH
11754 do
11755   IFS=$as_save_IFS
11756   test -z "$as_dir" && as_dir=.
11757   for ac_exec_ext in '' $ac_executable_extensions; do
11758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11759     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11761     break 2
11762   fi
11763 done
11764 done
11765
11766 fi
11767 fi
11768 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11769 if test -n "$WINDRES_FOR_TARGET"; then
11770   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11771 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11772 else
11773   echo "$as_me:$LINENO: result: no" >&5
11774 echo "${ECHO_T}no" >&6
11775 fi
11776
11777     fi
11778     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11779   done
11780 fi
11781
11782 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11783   set dummy windres
11784   if test $build = $target ; then
11785     WINDRES_FOR_TARGET="$2"
11786   else
11787     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11788   fi
11789 else
11790   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11791 fi
11792
11793 else
11794   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11795 fi
11796
11797
11798
11799
11800 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11801   if test -n "$with_build_time_tools"; then
11802     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11803 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11804     if test -x $with_build_time_tools/windmc; then
11805       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11806       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11807       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11808 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11809     else
11810       echo "$as_me:$LINENO: result: no" >&5
11811 echo "${ECHO_T}no" >&6
11812     fi
11813   elif test $build != $host && test $have_gcc_for_target = yes; then
11814     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11815     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11816     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11817   fi
11818 fi
11819 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11820   # Extract the first word of "windmc", so it can be a program name with args.
11821 set dummy windmc; ac_word=$2
11822 echo "$as_me:$LINENO: checking for $ac_word" >&5
11823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11824 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11825   echo $ECHO_N "(cached) $ECHO_C" >&6
11826 else
11827   case $WINDMC_FOR_TARGET in
11828   [\\/]* | ?:[\\/]*)
11829   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11830   ;;
11831   *)
11832   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11833 for as_dir in $gcc_cv_tool_dirs
11834 do
11835   IFS=$as_save_IFS
11836   test -z "$as_dir" && as_dir=.
11837   for ac_exec_ext in '' $ac_executable_extensions; do
11838   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11839     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11840     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11841     break 2
11842   fi
11843 done
11844 done
11845
11846   ;;
11847 esac
11848 fi
11849 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11850
11851 if test -n "$WINDMC_FOR_TARGET"; then
11852   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11853 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11854 else
11855   echo "$as_me:$LINENO: result: no" >&5
11856 echo "${ECHO_T}no" >&6
11857 fi
11858
11859 fi
11860 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11861
11862
11863 if test -n "$WINDMC_FOR_TARGET"; then
11864   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11865 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11866   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11867 fi
11868
11869 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11870   for ncn_progname in windmc; do
11871     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11872 set dummy ${ncn_progname}; ac_word=$2
11873 echo "$as_me:$LINENO: checking for $ac_word" >&5
11874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11875 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11876   echo $ECHO_N "(cached) $ECHO_C" >&6
11877 else
11878   if test -n "$WINDMC_FOR_TARGET"; then
11879   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11880 else
11881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11882 for as_dir in $PATH
11883 do
11884   IFS=$as_save_IFS
11885   test -z "$as_dir" && as_dir=.
11886   for ac_exec_ext in '' $ac_executable_extensions; do
11887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11888     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11890     break 2
11891   fi
11892 done
11893 done
11894
11895 fi
11896 fi
11897 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11898 if test -n "$WINDMC_FOR_TARGET"; then
11899   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11900 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11901 else
11902   echo "$as_me:$LINENO: result: no" >&5
11903 echo "${ECHO_T}no" >&6
11904 fi
11905
11906   done
11907 fi
11908
11909 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11910   for ncn_progname in windmc; do
11911     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11912 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11913     if test -x $with_build_time_tools/${ncn_progname}; then
11914       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11915       echo "$as_me:$LINENO: result: yes" >&5
11916 echo "${ECHO_T}yes" >&6
11917       break
11918     else
11919       echo "$as_me:$LINENO: result: no" >&5
11920 echo "${ECHO_T}no" >&6
11921     fi
11922   done
11923 fi
11924
11925 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11926   for ncn_progname in windmc; do
11927     if test -n "$ncn_target_tool_prefix"; then
11928       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11929 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11930 echo "$as_me:$LINENO: checking for $ac_word" >&5
11931 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11932 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11933   echo $ECHO_N "(cached) $ECHO_C" >&6
11934 else
11935   if test -n "$WINDMC_FOR_TARGET"; then
11936   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11937 else
11938 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11939 for as_dir in $PATH
11940 do
11941   IFS=$as_save_IFS
11942   test -z "$as_dir" && as_dir=.
11943   for ac_exec_ext in '' $ac_executable_extensions; do
11944   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11945     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11946     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11947     break 2
11948   fi
11949 done
11950 done
11951
11952 fi
11953 fi
11954 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11955 if test -n "$WINDMC_FOR_TARGET"; then
11956   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11957 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11958 else
11959   echo "$as_me:$LINENO: result: no" >&5
11960 echo "${ECHO_T}no" >&6
11961 fi
11962
11963     fi
11964     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11965       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11966 set dummy ${ncn_progname}; ac_word=$2
11967 echo "$as_me:$LINENO: checking for $ac_word" >&5
11968 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11969 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11970   echo $ECHO_N "(cached) $ECHO_C" >&6
11971 else
11972   if test -n "$WINDMC_FOR_TARGET"; then
11973   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11974 else
11975 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11976 for as_dir in $PATH
11977 do
11978   IFS=$as_save_IFS
11979   test -z "$as_dir" && as_dir=.
11980   for ac_exec_ext in '' $ac_executable_extensions; do
11981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11982     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11984     break 2
11985   fi
11986 done
11987 done
11988
11989 fi
11990 fi
11991 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11992 if test -n "$WINDMC_FOR_TARGET"; then
11993   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11994 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11995 else
11996   echo "$as_me:$LINENO: result: no" >&5
11997 echo "${ECHO_T}no" >&6
11998 fi
11999
12000     fi
12001     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
12002   done
12003 fi
12004
12005 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
12006   set dummy windmc
12007   if test $build = $target ; then
12008     WINDMC_FOR_TARGET="$2"
12009   else
12010     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
12011   fi
12012 else
12013   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
12014 fi
12015
12016 else
12017   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
12018 fi
12019
12020
12021 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
12022
12023 echo "$as_me:$LINENO: checking where to find the target ar" >&5
12024 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
12025 if test "x${build}" != "x${host}" ; then
12026   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12027     # We already found the complete path
12028     ac_dir=`dirname $AR_FOR_TARGET`
12029     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12030 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12031   else
12032     # Canadian cross, just use what we found
12033     echo "$as_me:$LINENO: result: pre-installed" >&5
12034 echo "${ECHO_T}pre-installed" >&6
12035   fi
12036 else
12037   ok=yes
12038   case " ${configdirs} " in
12039     *" binutils "*) ;;
12040     *) ok=no ;;
12041   esac
12042
12043   if test $ok = yes; then
12044     # An in-tree tool is available and we can use it
12045     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
12046     echo "$as_me:$LINENO: result: just compiled" >&5
12047 echo "${ECHO_T}just compiled" >&6
12048   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12049     # We already found the complete path
12050     ac_dir=`dirname $AR_FOR_TARGET`
12051     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12052 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12053   elif test "x$target" = "x$host"; then
12054     # We can use an host tool
12055     AR_FOR_TARGET='$(AR)'
12056     echo "$as_me:$LINENO: result: host tool" >&5
12057 echo "${ECHO_T}host tool" >&6
12058   else
12059     # We need a cross tool
12060     echo "$as_me:$LINENO: result: pre-installed" >&5
12061 echo "${ECHO_T}pre-installed" >&6
12062   fi
12063 fi
12064
12065 echo "$as_me:$LINENO: checking where to find the target as" >&5
12066 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
12067 if test "x${build}" != "x${host}" ; then
12068   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12069     # We already found the complete path
12070     ac_dir=`dirname $AS_FOR_TARGET`
12071     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12072 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12073   else
12074     # Canadian cross, just use what we found
12075     echo "$as_me:$LINENO: result: pre-installed" >&5
12076 echo "${ECHO_T}pre-installed" >&6
12077   fi
12078 else
12079   ok=yes
12080   case " ${configdirs} " in
12081     *" gas "*) ;;
12082     *) ok=no ;;
12083   esac
12084
12085   if test $ok = yes; then
12086     # An in-tree tool is available and we can use it
12087     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
12088     echo "$as_me:$LINENO: result: just compiled" >&5
12089 echo "${ECHO_T}just compiled" >&6
12090   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12091     # We already found the complete path
12092     ac_dir=`dirname $AS_FOR_TARGET`
12093     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12094 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12095   elif test "x$target" = "x$host"; then
12096     # We can use an host tool
12097     AS_FOR_TARGET='$(AS)'
12098     echo "$as_me:$LINENO: result: host tool" >&5
12099 echo "${ECHO_T}host tool" >&6
12100   else
12101     # We need a cross tool
12102     echo "$as_me:$LINENO: result: pre-installed" >&5
12103 echo "${ECHO_T}pre-installed" >&6
12104   fi
12105 fi
12106
12107 echo "$as_me:$LINENO: checking where to find the target cc" >&5
12108 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12109 if test "x${build}" != "x${host}" ; then
12110   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12111     # We already found the complete path
12112     ac_dir=`dirname $CC_FOR_TARGET`
12113     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12114 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12115   else
12116     # Canadian cross, just use what we found
12117     echo "$as_me:$LINENO: result: pre-installed" >&5
12118 echo "${ECHO_T}pre-installed" >&6
12119   fi
12120 else
12121   ok=yes
12122   case " ${configdirs} " in
12123     *" gcc "*) ;;
12124     *) ok=no ;;
12125   esac
12126
12127   if test $ok = yes; then
12128     # An in-tree tool is available and we can use it
12129     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12130     echo "$as_me:$LINENO: result: just compiled" >&5
12131 echo "${ECHO_T}just compiled" >&6
12132   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12133     # We already found the complete path
12134     ac_dir=`dirname $CC_FOR_TARGET`
12135     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12136 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12137   elif test "x$target" = "x$host"; then
12138     # We can use an host tool
12139     CC_FOR_TARGET='$(CC)'
12140     echo "$as_me:$LINENO: result: host tool" >&5
12141 echo "${ECHO_T}host tool" >&6
12142   else
12143     # We need a cross tool
12144     echo "$as_me:$LINENO: result: pre-installed" >&5
12145 echo "${ECHO_T}pre-installed" >&6
12146   fi
12147 fi
12148
12149 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12150 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12151 if test "x${build}" != "x${host}" ; then
12152   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12153     # We already found the complete path
12154     ac_dir=`dirname $CXX_FOR_TARGET`
12155     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12156 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12157   else
12158     # Canadian cross, just use what we found
12159     echo "$as_me:$LINENO: result: pre-installed" >&5
12160 echo "${ECHO_T}pre-installed" >&6
12161   fi
12162 else
12163   ok=yes
12164   case " ${configdirs} " in
12165     *" gcc "*) ;;
12166     *) ok=no ;;
12167   esac
12168   case ,${enable_languages}, in
12169     *,c++,*) ;;
12170     *) ok=no ;;
12171   esac
12172   if test $ok = yes; then
12173     # An in-tree tool is available and we can use it
12174     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'
12175     echo "$as_me:$LINENO: result: just compiled" >&5
12176 echo "${ECHO_T}just compiled" >&6
12177   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12178     # We already found the complete path
12179     ac_dir=`dirname $CXX_FOR_TARGET`
12180     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12181 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12182   elif test "x$target" = "x$host"; then
12183     # We can use an host tool
12184     CXX_FOR_TARGET='$(CXX)'
12185     echo "$as_me:$LINENO: result: host tool" >&5
12186 echo "${ECHO_T}host tool" >&6
12187   else
12188     # We need a cross tool
12189     echo "$as_me:$LINENO: result: pre-installed" >&5
12190 echo "${ECHO_T}pre-installed" >&6
12191   fi
12192 fi
12193
12194 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12195 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12196 if test "x${build}" != "x${host}" ; then
12197   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12198     # We already found the complete path
12199     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12200     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12201 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12202   else
12203     # Canadian cross, just use what we found
12204     echo "$as_me:$LINENO: result: pre-installed" >&5
12205 echo "${ECHO_T}pre-installed" >&6
12206   fi
12207 else
12208   ok=yes
12209   case " ${configdirs} " in
12210     *" gcc "*) ;;
12211     *) ok=no ;;
12212   esac
12213   case ,${enable_languages}, in
12214     *,c++,*) ;;
12215     *) ok=no ;;
12216   esac
12217   if test $ok = yes; then
12218     # An in-tree tool is available and we can use it
12219     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'
12220     echo "$as_me:$LINENO: result: just compiled" >&5
12221 echo "${ECHO_T}just compiled" >&6
12222   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12223     # We already found the complete path
12224     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12225     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12226 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12227   elif test "x$target" = "x$host"; then
12228     # We can use an host tool
12229     RAW_CXX_FOR_TARGET='$(CXX)'
12230     echo "$as_me:$LINENO: result: host tool" >&5
12231 echo "${ECHO_T}host tool" >&6
12232   else
12233     # We need a cross tool
12234     echo "$as_me:$LINENO: result: pre-installed" >&5
12235 echo "${ECHO_T}pre-installed" >&6
12236   fi
12237 fi
12238
12239 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12240 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12241 if test "x${build}" != "x${host}" ; then
12242   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12243     # We already found the complete path
12244     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12245     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12246 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12247   else
12248     # Canadian cross, just use what we found
12249     echo "$as_me:$LINENO: result: pre-installed" >&5
12250 echo "${ECHO_T}pre-installed" >&6
12251   fi
12252 else
12253   ok=yes
12254   case " ${configdirs} " in
12255     *" binutils "*) ;;
12256     *) ok=no ;;
12257   esac
12258
12259   if test $ok = yes; then
12260     # An in-tree tool is available and we can use it
12261     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12262     echo "$as_me:$LINENO: result: just compiled" >&5
12263 echo "${ECHO_T}just compiled" >&6
12264   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12265     # We already found the complete path
12266     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12267     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12268 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12269   elif test "x$target" = "x$host"; then
12270     # We can use an host tool
12271     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12272     echo "$as_me:$LINENO: result: host tool" >&5
12273 echo "${ECHO_T}host tool" >&6
12274   else
12275     # We need a cross tool
12276     echo "$as_me:$LINENO: result: pre-installed" >&5
12277 echo "${ECHO_T}pre-installed" >&6
12278   fi
12279 fi
12280
12281 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12282 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12283 if test "x${build}" != "x${host}" ; then
12284   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12285     # We already found the complete path
12286     ac_dir=`dirname $GCC_FOR_TARGET`
12287     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12288 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12289   else
12290     # Canadian cross, just use what we found
12291     echo "$as_me:$LINENO: result: pre-installed" >&5
12292 echo "${ECHO_T}pre-installed" >&6
12293   fi
12294 else
12295   ok=yes
12296   case " ${configdirs} " in
12297     *" gcc "*) ;;
12298     *) ok=no ;;
12299   esac
12300
12301   if test $ok = yes; then
12302     # An in-tree tool is available and we can use it
12303     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12304     echo "$as_me:$LINENO: result: just compiled" >&5
12305 echo "${ECHO_T}just compiled" >&6
12306   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12307     # We already found the complete path
12308     ac_dir=`dirname $GCC_FOR_TARGET`
12309     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12310 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12311   elif test "x$target" = "x$host"; then
12312     # We can use an host tool
12313     GCC_FOR_TARGET='$()'
12314     echo "$as_me:$LINENO: result: host tool" >&5
12315 echo "${ECHO_T}host tool" >&6
12316   else
12317     # We need a cross tool
12318     echo "$as_me:$LINENO: result: pre-installed" >&5
12319 echo "${ECHO_T}pre-installed" >&6
12320   fi
12321 fi
12322
12323 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12324 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12325 if test "x${build}" != "x${host}" ; then
12326   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12327     # We already found the complete path
12328     ac_dir=`dirname $GCJ_FOR_TARGET`
12329     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12330 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12331   else
12332     # Canadian cross, just use what we found
12333     echo "$as_me:$LINENO: result: pre-installed" >&5
12334 echo "${ECHO_T}pre-installed" >&6
12335   fi
12336 else
12337   ok=yes
12338   case " ${configdirs} " in
12339     *" gcc "*) ;;
12340     *) ok=no ;;
12341   esac
12342   case ,${enable_languages}, in
12343     *,java,*) ;;
12344     *) ok=no ;;
12345   esac
12346   if test $ok = yes; then
12347     # An in-tree tool is available and we can use it
12348     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12349     echo "$as_me:$LINENO: result: just compiled" >&5
12350 echo "${ECHO_T}just compiled" >&6
12351   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12352     # We already found the complete path
12353     ac_dir=`dirname $GCJ_FOR_TARGET`
12354     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12355 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12356   elif test "x$target" = "x$host"; then
12357     # We can use an host tool
12358     GCJ_FOR_TARGET='$(GCJ)'
12359     echo "$as_me:$LINENO: result: host tool" >&5
12360 echo "${ECHO_T}host tool" >&6
12361   else
12362     # We need a cross tool
12363     echo "$as_me:$LINENO: result: pre-installed" >&5
12364 echo "${ECHO_T}pre-installed" >&6
12365   fi
12366 fi
12367
12368 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12369 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12370 if test "x${build}" != "x${host}" ; then
12371   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12372     # We already found the complete path
12373     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12374     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12375 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12376   else
12377     # Canadian cross, just use what we found
12378     echo "$as_me:$LINENO: result: pre-installed" >&5
12379 echo "${ECHO_T}pre-installed" >&6
12380   fi
12381 else
12382   ok=yes
12383   case " ${configdirs} " in
12384     *" gcc "*) ;;
12385     *) ok=no ;;
12386   esac
12387   case ,${enable_languages}, in
12388     *,fortran,*) ;;
12389     *) ok=no ;;
12390   esac
12391   if test $ok = yes; then
12392     # An in-tree tool is available and we can use it
12393     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12394     echo "$as_me:$LINENO: result: just compiled" >&5
12395 echo "${ECHO_T}just compiled" >&6
12396   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12397     # We already found the complete path
12398     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12399     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12400 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12401   elif test "x$target" = "x$host"; then
12402     # We can use an host tool
12403     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12404     echo "$as_me:$LINENO: result: host tool" >&5
12405 echo "${ECHO_T}host tool" >&6
12406   else
12407     # We need a cross tool
12408     echo "$as_me:$LINENO: result: pre-installed" >&5
12409 echo "${ECHO_T}pre-installed" >&6
12410   fi
12411 fi
12412
12413 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12414 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12415 if test "x${build}" != "x${host}" ; then
12416   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12417     # We already found the complete path
12418     ac_dir=`dirname $LD_FOR_TARGET`
12419     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12420 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12421   else
12422     # Canadian cross, just use what we found
12423     echo "$as_me:$LINENO: result: pre-installed" >&5
12424 echo "${ECHO_T}pre-installed" >&6
12425   fi
12426 else
12427   ok=yes
12428   case " ${configdirs} " in
12429     *" ld "*) ;;
12430     *) ok=no ;;
12431   esac
12432
12433   if test $ok = yes; then
12434     # An in-tree tool is available and we can use it
12435     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12436     echo "$as_me:$LINENO: result: just compiled" >&5
12437 echo "${ECHO_T}just compiled" >&6
12438   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12439     # We already found the complete path
12440     ac_dir=`dirname $LD_FOR_TARGET`
12441     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12442 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12443   elif test "x$target" = "x$host"; then
12444     # We can use an host tool
12445     LD_FOR_TARGET='$(LD)'
12446     echo "$as_me:$LINENO: result: host tool" >&5
12447 echo "${ECHO_T}host tool" >&6
12448   else
12449     # We need a cross tool
12450     echo "$as_me:$LINENO: result: pre-installed" >&5
12451 echo "${ECHO_T}pre-installed" >&6
12452   fi
12453 fi
12454
12455 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12456 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12457 if test "x${build}" != "x${host}" ; then
12458   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12459     # We already found the complete path
12460     ac_dir=`dirname $LIPO_FOR_TARGET`
12461     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12462 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12463   else
12464     # Canadian cross, just use what we found
12465     echo "$as_me:$LINENO: result: pre-installed" >&5
12466 echo "${ECHO_T}pre-installed" >&6
12467   fi
12468 else
12469   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12470     # We already found the complete path
12471     ac_dir=`dirname $LIPO_FOR_TARGET`
12472     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12473 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12474   elif test "x$target" = "x$host"; then
12475     # We can use an host tool
12476     LIPO_FOR_TARGET='$(LIPO)'
12477     echo "$as_me:$LINENO: result: host tool" >&5
12478 echo "${ECHO_T}host tool" >&6
12479   else
12480     # We need a cross tool
12481     echo "$as_me:$LINENO: result: pre-installed" >&5
12482 echo "${ECHO_T}pre-installed" >&6
12483   fi
12484 fi
12485
12486 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12487 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12488 if test "x${build}" != "x${host}" ; then
12489   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12490     # We already found the complete path
12491     ac_dir=`dirname $NM_FOR_TARGET`
12492     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12493 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12494   else
12495     # Canadian cross, just use what we found
12496     echo "$as_me:$LINENO: result: pre-installed" >&5
12497 echo "${ECHO_T}pre-installed" >&6
12498   fi
12499 else
12500   ok=yes
12501   case " ${configdirs} " in
12502     *" binutils "*) ;;
12503     *) ok=no ;;
12504   esac
12505
12506   if test $ok = yes; then
12507     # An in-tree tool is available and we can use it
12508     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12509     echo "$as_me:$LINENO: result: just compiled" >&5
12510 echo "${ECHO_T}just compiled" >&6
12511   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12512     # We already found the complete path
12513     ac_dir=`dirname $NM_FOR_TARGET`
12514     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12515 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12516   elif test "x$target" = "x$host"; then
12517     # We can use an host tool
12518     NM_FOR_TARGET='$(NM)'
12519     echo "$as_me:$LINENO: result: host tool" >&5
12520 echo "${ECHO_T}host tool" >&6
12521   else
12522     # We need a cross tool
12523     echo "$as_me:$LINENO: result: pre-installed" >&5
12524 echo "${ECHO_T}pre-installed" >&6
12525   fi
12526 fi
12527
12528 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12529 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12530 if test "x${build}" != "x${host}" ; then
12531   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12532     # We already found the complete path
12533     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12534     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12535 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12536   else
12537     # Canadian cross, just use what we found
12538     echo "$as_me:$LINENO: result: pre-installed" >&5
12539 echo "${ECHO_T}pre-installed" >&6
12540   fi
12541 else
12542   ok=yes
12543   case " ${configdirs} " in
12544     *" binutils "*) ;;
12545     *) ok=no ;;
12546   esac
12547
12548   if test $ok = yes; then
12549     # An in-tree tool is available and we can use it
12550     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12551     echo "$as_me:$LINENO: result: just compiled" >&5
12552 echo "${ECHO_T}just compiled" >&6
12553   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12554     # We already found the complete path
12555     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12556     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12557 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12558   elif test "x$target" = "x$host"; then
12559     # We can use an host tool
12560     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12561     echo "$as_me:$LINENO: result: host tool" >&5
12562 echo "${ECHO_T}host tool" >&6
12563   else
12564     # We need a cross tool
12565     echo "$as_me:$LINENO: result: pre-installed" >&5
12566 echo "${ECHO_T}pre-installed" >&6
12567   fi
12568 fi
12569
12570 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12571 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12572 if test "x${build}" != "x${host}" ; then
12573   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12574     # We already found the complete path
12575     ac_dir=`dirname $RANLIB_FOR_TARGET`
12576     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12577 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12578   else
12579     # Canadian cross, just use what we found
12580     echo "$as_me:$LINENO: result: pre-installed" >&5
12581 echo "${ECHO_T}pre-installed" >&6
12582   fi
12583 else
12584   ok=yes
12585   case " ${configdirs} " in
12586     *" binutils "*) ;;
12587     *) ok=no ;;
12588   esac
12589
12590   if test $ok = yes; then
12591     # An in-tree tool is available and we can use it
12592     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12593     echo "$as_me:$LINENO: result: just compiled" >&5
12594 echo "${ECHO_T}just compiled" >&6
12595   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12596     # We already found the complete path
12597     ac_dir=`dirname $RANLIB_FOR_TARGET`
12598     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12599 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12600   elif test "x$target" = "x$host"; then
12601     # We can use an host tool
12602     RANLIB_FOR_TARGET='$(RANLIB)'
12603     echo "$as_me:$LINENO: result: host tool" >&5
12604 echo "${ECHO_T}host tool" >&6
12605   else
12606     # We need a cross tool
12607     echo "$as_me:$LINENO: result: pre-installed" >&5
12608 echo "${ECHO_T}pre-installed" >&6
12609   fi
12610 fi
12611
12612 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12613 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12614 if test "x${build}" != "x${host}" ; then
12615   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12616     # We already found the complete path
12617     ac_dir=`dirname $STRIP_FOR_TARGET`
12618     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12619 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12620   else
12621     # Canadian cross, just use what we found
12622     echo "$as_me:$LINENO: result: pre-installed" >&5
12623 echo "${ECHO_T}pre-installed" >&6
12624   fi
12625 else
12626   ok=yes
12627   case " ${configdirs} " in
12628     *" binutils "*) ;;
12629     *) ok=no ;;
12630   esac
12631
12632   if test $ok = yes; then
12633     # An in-tree tool is available and we can use it
12634     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12635     echo "$as_me:$LINENO: result: just compiled" >&5
12636 echo "${ECHO_T}just compiled" >&6
12637   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12638     # We already found the complete path
12639     ac_dir=`dirname $STRIP_FOR_TARGET`
12640     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12641 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12642   elif test "x$target" = "x$host"; then
12643     # We can use an host tool
12644     STRIP_FOR_TARGET='$(STRIP)'
12645     echo "$as_me:$LINENO: result: host tool" >&5
12646 echo "${ECHO_T}host tool" >&6
12647   else
12648     # We need a cross tool
12649     echo "$as_me:$LINENO: result: pre-installed" >&5
12650 echo "${ECHO_T}pre-installed" >&6
12651   fi
12652 fi
12653
12654 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12655 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12656 if test "x${build}" != "x${host}" ; then
12657   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12658     # We already found the complete path
12659     ac_dir=`dirname $WINDRES_FOR_TARGET`
12660     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12661 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12662   else
12663     # Canadian cross, just use what we found
12664     echo "$as_me:$LINENO: result: pre-installed" >&5
12665 echo "${ECHO_T}pre-installed" >&6
12666   fi
12667 else
12668   ok=yes
12669   case " ${configdirs} " in
12670     *" binutils "*) ;;
12671     *) ok=no ;;
12672   esac
12673
12674   if test $ok = yes; then
12675     # An in-tree tool is available and we can use it
12676     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12677     echo "$as_me:$LINENO: result: just compiled" >&5
12678 echo "${ECHO_T}just compiled" >&6
12679   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12680     # We already found the complete path
12681     ac_dir=`dirname $WINDRES_FOR_TARGET`
12682     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12683 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12684   elif test "x$target" = "x$host"; then
12685     # We can use an host tool
12686     WINDRES_FOR_TARGET='$(WINDRES)'
12687     echo "$as_me:$LINENO: result: host tool" >&5
12688 echo "${ECHO_T}host tool" >&6
12689   else
12690     # We need a cross tool
12691     echo "$as_me:$LINENO: result: pre-installed" >&5
12692 echo "${ECHO_T}pre-installed" >&6
12693   fi
12694 fi
12695
12696 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12697 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12698 if test "x${build}" != "x${host}" ; then
12699   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12700     # We already found the complete path
12701     ac_dir=`dirname $WINDMC_FOR_TARGET`
12702     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12703 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12704   else
12705     # Canadian cross, just use what we found
12706     echo "$as_me:$LINENO: result: pre-installed" >&5
12707 echo "${ECHO_T}pre-installed" >&6
12708   fi
12709 else
12710   ok=yes
12711   case " ${configdirs} " in
12712     *" binutils "*) ;;
12713     *) ok=no ;;
12714   esac
12715
12716   if test $ok = yes; then
12717     # An in-tree tool is available and we can use it
12718     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12719     echo "$as_me:$LINENO: result: just compiled" >&5
12720 echo "${ECHO_T}just compiled" >&6
12721   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12722     # We already found the complete path
12723     ac_dir=`dirname $WINDMC_FOR_TARGET`
12724     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12725 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12726   elif test "x$target" = "x$host"; then
12727     # We can use an host tool
12728     WINDMC_FOR_TARGET='$(WINDMC)'
12729     echo "$as_me:$LINENO: result: host tool" >&5
12730 echo "${ECHO_T}host tool" >&6
12731   else
12732     # We need a cross tool
12733     echo "$as_me:$LINENO: result: pre-installed" >&5
12734 echo "${ECHO_T}pre-installed" >&6
12735   fi
12736 fi
12737
12738
12739
12740
12741
12742 # Certain tools may need extra flags.
12743 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12744 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12745 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12746
12747 # When building target libraries, except in a Canadian cross, we use
12748 # the same toolchain as the compiler we just built.
12749 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12750 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12751 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12752 if test $host = $build; then
12753   case " $configdirs " in
12754     *" gcc "*)
12755       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12756       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12757       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12758       ;;
12759   esac
12760 fi
12761
12762
12763
12764
12765
12766 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12767 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12768 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12769 if test "${enable_maintainer_mode+set}" = set; then
12770   enableval="$enable_maintainer_mode"
12771   USE_MAINTAINER_MODE=$enableval
12772 else
12773   USE_MAINTAINER_MODE=no
12774 fi;
12775 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12776 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12777
12778
12779 if test "$USE_MAINTAINER_MODE" = yes; then
12780   MAINTAINER_MODE_TRUE=
12781   MAINTAINER_MODE_FALSE='#'
12782 else
12783   MAINTAINER_MODE_TRUE='#'
12784   MAINTAINER_MODE_FALSE=
12785 fi
12786 MAINT=$MAINTAINER_MODE_TRUE
12787
12788 # ---------------------
12789 # GCC bootstrap support
12790 # ---------------------
12791
12792 # Stage specific cflags for build.
12793 stage1_cflags="-g"
12794 case $build in
12795   vax-*-*)
12796     case ${GCC} in
12797       yes) stage1_cflags="-g -Wa,-J" ;;
12798       *) stage1_cflags="-g -J" ;;
12799     esac ;;
12800 esac
12801
12802 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12803 if test "$GCC" = yes -a "$ENABLE_BUILD_WITH_CXX" != yes; then
12804   saved_CFLAGS="$CFLAGS"
12805
12806   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12807   CFLAGS="$CFLAGS -fkeep-inline-functions"
12808   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12809 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12810   cat >conftest.$ac_ext <<_ACEOF
12811 /* confdefs.h.  */
12812 _ACEOF
12813 cat confdefs.h >>conftest.$ac_ext
12814 cat >>conftest.$ac_ext <<_ACEOF
12815 /* end confdefs.h.  */
12816
12817 #if (__GNUC__ < 3) \
12818     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12819                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12820 #error http://gcc.gnu.org/PR29382
12821 #endif
12822
12823 int
12824 main ()
12825 {
12826
12827   ;
12828   return 0;
12829 }
12830 _ACEOF
12831 rm -f conftest.$ac_objext
12832 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12833   (eval $ac_compile) 2>conftest.er1
12834   ac_status=$?
12835   grep -v '^ *+' conftest.er1 >conftest.err
12836   rm -f conftest.er1
12837   cat conftest.err >&5
12838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12839   (exit $ac_status); } &&
12840          { ac_try='test -z "$ac_c_werror_flag"
12841                          || test ! -s conftest.err'
12842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12843   (eval $ac_try) 2>&5
12844   ac_status=$?
12845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12846   (exit $ac_status); }; } &&
12847          { ac_try='test -s conftest.$ac_objext'
12848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12849   (eval $ac_try) 2>&5
12850   ac_status=$?
12851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12852   (exit $ac_status); }; }; then
12853   echo "$as_me:$LINENO: result: yes" >&5
12854 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12855 else
12856   echo "$as_me: failed program was:" >&5
12857 sed 's/^/| /' conftest.$ac_ext >&5
12858
12859 echo "$as_me:$LINENO: result: no" >&5
12860 echo "${ECHO_T}no" >&6
12861 fi
12862 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12863
12864   CFLAGS="$saved_CFLAGS"
12865 fi
12866
12867
12868
12869 # Enable --enable-checking in stage1 of the compiler.
12870 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12871 if test "${enable_stage1_checking+set}" = set; then
12872   enableval="$enable_stage1_checking"
12873   stage1_checking=--enable-checking=${enable_stage1_checking}
12874 else
12875   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12876   stage1_checking=--enable-checking=yes,types
12877 else
12878   stage1_checking=--enable-checking=$enable_checking,types
12879 fi
12880 fi;
12881
12882
12883 # Enable -Werror in bootstrap stage2 and later.
12884 # Check whether --enable-werror or --disable-werror was given.
12885 if test "${enable_werror+set}" = set; then
12886   enableval="$enable_werror"
12887
12888 else
12889   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12890   enable_werror=yes
12891 else
12892   enable_werror=no
12893 fi
12894 fi;
12895 case ${enable_werror} in
12896   yes) stage2_werror_flag="--enable-werror-always" ;;
12897   *) stage2_werror_flag="" ;;
12898 esac
12899
12900
12901 # Flags needed to enable html installing and building
12902
12903 # Check whether --with-datarootdir or --without-datarootdir was given.
12904 if test "${with_datarootdir+set}" = set; then
12905   withval="$with_datarootdir"
12906   datarootdir="\${prefix}/${withval}"
12907 else
12908   datarootdir="\${prefix}/share"
12909 fi;
12910
12911
12912 # Check whether --with-docdir or --without-docdir was given.
12913 if test "${with_docdir+set}" = set; then
12914   withval="$with_docdir"
12915   docdir="\${prefix}/${withval}"
12916 else
12917   docdir="\${datarootdir}/doc"
12918 fi;
12919
12920
12921 # Check whether --with-pdfdir or --without-pdfdir was given.
12922 if test "${with_pdfdir+set}" = set; then
12923   withval="$with_pdfdir"
12924   pdfdir="\${prefix}/${withval}"
12925 else
12926   pdfdir="\${docdir}"
12927 fi;
12928
12929
12930 # Check whether --with-htmldir or --without-htmldir was given.
12931 if test "${with_htmldir+set}" = set; then
12932   withval="$with_htmldir"
12933   htmldir="\${prefix}/${withval}"
12934 else
12935   htmldir="\${docdir}"
12936 fi;
12937
12938
12939
12940
12941
12942
12943 # Specify what files to not compare during bootstrap.
12944
12945 compare_exclusions="gcc/cc*-checksum\$(objext) | gcc/ada/*tools/*"
12946 case "$target" in
12947   hppa*64*-*-hpux*) ;;
12948   hppa*-*-hpux*) compare_exclusions="gcc/cc*-checksum\$(objext) | */libgcc/lib2funcs* | gcc/ada/*tools/*" ;;
12949 esac
12950
12951
12952           ac_config_files="$ac_config_files Makefile"
12953 cat >confcache <<\_ACEOF
12954 # This file is a shell script that caches the results of configure
12955 # tests run on this system so they can be shared between configure
12956 # scripts and configure runs, see configure's option --config-cache.
12957 # It is not useful on other systems.  If it contains results you don't
12958 # want to keep, you may remove or edit it.
12959 #
12960 # config.status only pays attention to the cache file if you give it
12961 # the --recheck option to rerun configure.
12962 #
12963 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12964 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12965 # following values.
12966
12967 _ACEOF
12968
12969 # The following way of writing the cache mishandles newlines in values,
12970 # but we know of no workaround that is simple, portable, and efficient.
12971 # So, don't put newlines in cache variables' values.
12972 # Ultrix sh set writes to stderr and can't be redirected directly,
12973 # and sets the high bit in the cache file unless we assign to the vars.
12974 {
12975   (set) 2>&1 |
12976     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12977     *ac_space=\ *)
12978       # `set' does not quote correctly, so add quotes (double-quote
12979       # substitution turns \\\\ into \\, and sed turns \\ into \).
12980       sed -n \
12981         "s/'/'\\\\''/g;
12982           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12983       ;;
12984     *)
12985       # `set' quotes correctly as required by POSIX, so do not add quotes.
12986       sed -n \
12987         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12988       ;;
12989     esac;
12990 } |
12991   sed '
12992      t clear
12993      : clear
12994      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12995      t end
12996      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12997      : end' >>confcache
12998 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12999   if test -w $cache_file; then
13000     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
13001     cat confcache >$cache_file
13002   else
13003     echo "not updating unwritable cache $cache_file"
13004   fi
13005 fi
13006 rm -f confcache
13007
13008 test "x$prefix" = xNONE && prefix=$ac_default_prefix
13009 # Let make expand exec_prefix.
13010 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
13011
13012 # VPATH may cause trouble with some makes, so we remove $(srcdir),
13013 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
13014 # trailing colons and then remove the whole line if VPATH becomes empty
13015 # (actually we leave an empty line to preserve line numbers).
13016 if test "x$srcdir" = x.; then
13017   ac_vpsub='/^[  ]*VPATH[        ]*=/{
13018 s/:*\$(srcdir):*/:/;
13019 s/:*\${srcdir}:*/:/;
13020 s/:*@srcdir@:*/:/;
13021 s/^\([^=]*=[     ]*\):*/\1/;
13022 s/:*$//;
13023 s/^[^=]*=[       ]*$//;
13024 }'
13025 fi
13026
13027 # Transform confdefs.h into DEFS.
13028 # Protect against shell expansion while executing Makefile rules.
13029 # Protect against Makefile macro expansion.
13030 #
13031 # If the first sed substitution is executed (which looks for macros that
13032 # take arguments), then we branch to the quote section.  Otherwise,
13033 # look for a macro that doesn't take arguments.
13034 cat >confdef2opt.sed <<\_ACEOF
13035 t clear
13036 : clear
13037 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
13038 t quote
13039 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
13040 t quote
13041 d
13042 : quote
13043 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
13044 s,\[,\\&,g
13045 s,\],\\&,g
13046 s,\$,$$,g
13047 p
13048 _ACEOF
13049 # We use echo to avoid assuming a particular line-breaking character.
13050 # The extra dot is to prevent the shell from consuming trailing
13051 # line-breaks from the sub-command output.  A line-break within
13052 # single-quotes doesn't work because, if this script is created in a
13053 # platform that uses two characters for line-breaks (e.g., DOS), tr
13054 # would break.
13055 ac_LF_and_DOT=`echo; echo .`
13056 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
13057 rm -f confdef2opt.sed
13058
13059
13060 ac_libobjs=
13061 ac_ltlibobjs=
13062 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
13063   # 1. Remove the extension, and $U if already installed.
13064   ac_i=`echo "$ac_i" |
13065          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
13066   # 2. Add them.
13067   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
13068   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
13069 done
13070 LIBOBJS=$ac_libobjs
13071
13072 LTLIBOBJS=$ac_ltlibobjs
13073
13074
13075
13076 : ${CONFIG_STATUS=./config.status}
13077 ac_clean_files_save=$ac_clean_files
13078 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
13079 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
13080 echo "$as_me: creating $CONFIG_STATUS" >&6;}
13081 cat >$CONFIG_STATUS <<_ACEOF
13082 #! $SHELL
13083 # Generated by $as_me.
13084 # Run this file to recreate the current configuration.
13085 # Compiler output produced by configure, useful for debugging
13086 # configure, is in config.log if it exists.
13087
13088 debug=false
13089 ac_cs_recheck=false
13090 ac_cs_silent=false
13091 SHELL=\${CONFIG_SHELL-$SHELL}
13092 _ACEOF
13093
13094 cat >>$CONFIG_STATUS <<\_ACEOF
13095 ## --------------------- ##
13096 ## M4sh Initialization.  ##
13097 ## --------------------- ##
13098
13099 # Be Bourne compatible
13100 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
13101   emulate sh
13102   NULLCMD=:
13103   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
13104   # is contrary to our usage.  Disable this feature.
13105   alias -g '${1+"$@"}'='"$@"'
13106 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
13107   set -o posix
13108 fi
13109 DUALCASE=1; export DUALCASE # for MKS sh
13110
13111 # Support unset when possible.
13112 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13113   as_unset=unset
13114 else
13115   as_unset=false
13116 fi
13117
13118
13119 # Work around bugs in pre-3.0 UWIN ksh.
13120 $as_unset ENV MAIL MAILPATH
13121 PS1='$ '
13122 PS2='> '
13123 PS4='+ '
13124
13125 # NLS nuisances.
13126 for as_var in \
13127   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13128   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13129   LC_TELEPHONE LC_TIME
13130 do
13131   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13132     eval $as_var=C; export $as_var
13133   else
13134     $as_unset $as_var
13135   fi
13136 done
13137
13138 # Required to use basename.
13139 if expr a : '\(a\)' >/dev/null 2>&1; then
13140   as_expr=expr
13141 else
13142   as_expr=false
13143 fi
13144
13145 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13146   as_basename=basename
13147 else
13148   as_basename=false
13149 fi
13150
13151
13152 # Name of the executable.
13153 as_me=`$as_basename "$0" ||
13154 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13155          X"$0" : 'X\(//\)$' \| \
13156          X"$0" : 'X\(/\)$' \| \
13157          .     : '\(.\)' 2>/dev/null ||
13158 echo X/"$0" |
13159     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13160           /^X\/\(\/\/\)$/{ s//\1/; q; }
13161           /^X\/\(\/\).*/{ s//\1/; q; }
13162           s/.*/./; q'`
13163
13164
13165 # PATH needs CR, and LINENO needs CR and PATH.
13166 # Avoid depending upon Character Ranges.
13167 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13168 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13169 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13170 as_cr_digits='0123456789'
13171 as_cr_alnum=$as_cr_Letters$as_cr_digits
13172
13173 # The user is always right.
13174 if test "${PATH_SEPARATOR+set}" != set; then
13175   echo "#! /bin/sh" >conf$$.sh
13176   echo  "exit 0"   >>conf$$.sh
13177   chmod +x conf$$.sh
13178   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13179     PATH_SEPARATOR=';'
13180   else
13181     PATH_SEPARATOR=:
13182   fi
13183   rm -f conf$$.sh
13184 fi
13185
13186
13187   as_lineno_1=$LINENO
13188   as_lineno_2=$LINENO
13189   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13190   test "x$as_lineno_1" != "x$as_lineno_2" &&
13191   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13192   # Find who we are.  Look in the path if we contain no path at all
13193   # relative or not.
13194   case $0 in
13195     *[\\/]* ) as_myself=$0 ;;
13196     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13197 for as_dir in $PATH
13198 do
13199   IFS=$as_save_IFS
13200   test -z "$as_dir" && as_dir=.
13201   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13202 done
13203
13204        ;;
13205   esac
13206   # We did not find ourselves, most probably we were run as `sh COMMAND'
13207   # in which case we are not to be found in the path.
13208   if test "x$as_myself" = x; then
13209     as_myself=$0
13210   fi
13211   if test ! -f "$as_myself"; then
13212     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13213 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13214    { (exit 1); exit 1; }; }
13215   fi
13216   case $CONFIG_SHELL in
13217   '')
13218     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13219 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13220 do
13221   IFS=$as_save_IFS
13222   test -z "$as_dir" && as_dir=.
13223   for as_base in sh bash ksh sh5; do
13224          case $as_dir in
13225          /*)
13226            if ("$as_dir/$as_base" -c '
13227   as_lineno_1=$LINENO
13228   as_lineno_2=$LINENO
13229   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13230   test "x$as_lineno_1" != "x$as_lineno_2" &&
13231   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13232              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13233              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13234              CONFIG_SHELL=$as_dir/$as_base
13235              export CONFIG_SHELL
13236              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13237            fi;;
13238          esac
13239        done
13240 done
13241 ;;
13242   esac
13243
13244   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13245   # uniformly replaced by the line number.  The first 'sed' inserts a
13246   # line-number line before each line; the second 'sed' does the real
13247   # work.  The second script uses 'N' to pair each line-number line
13248   # with the numbered line, and appends trailing '-' during
13249   # substitution so that $LINENO is not a special case at line end.
13250   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13251   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13252   sed '=' <$as_myself |
13253     sed '
13254       N
13255       s,$,-,
13256       : loop
13257       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13258       t loop
13259       s,-$,,
13260       s,^['$as_cr_digits']*\n,,
13261     ' >$as_me.lineno &&
13262   chmod +x $as_me.lineno ||
13263     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13264 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13265    { (exit 1); exit 1; }; }
13266
13267   # Don't try to exec as it changes $[0], causing all sort of problems
13268   # (the dirname of $[0] is not the place where we might find the
13269   # original and so on.  Autoconf is especially sensible to this).
13270   . ./$as_me.lineno
13271   # Exit status is that of the last command.
13272   exit
13273 }
13274
13275
13276 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13277   *c*,-n*) ECHO_N= ECHO_C='
13278 ' ECHO_T='      ' ;;
13279   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13280   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13281 esac
13282
13283 if expr a : '\(a\)' >/dev/null 2>&1; then
13284   as_expr=expr
13285 else
13286   as_expr=false
13287 fi
13288
13289 rm -f conf$$ conf$$.exe conf$$.file
13290 echo >conf$$.file
13291 if ln -s conf$$.file conf$$ 2>/dev/null; then
13292   # We could just check for DJGPP; but this test a) works b) is more generic
13293   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13294   if test -f conf$$.exe; then
13295     # Don't use ln at all; we don't have any links
13296     as_ln_s='cp -p'
13297   else
13298     as_ln_s='ln -s'
13299   fi
13300 elif ln conf$$.file conf$$ 2>/dev/null; then
13301   as_ln_s=ln
13302 else
13303   as_ln_s='cp -p'
13304 fi
13305 rm -f conf$$ conf$$.exe conf$$.file
13306
13307 if mkdir -p . 2>/dev/null; then
13308   as_mkdir_p=:
13309 else
13310   test -d ./-p && rmdir ./-p
13311   as_mkdir_p=false
13312 fi
13313
13314 as_executable_p="test -f"
13315
13316 # Sed expression to map a string onto a valid CPP name.
13317 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13318
13319 # Sed expression to map a string onto a valid variable name.
13320 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13321
13322
13323 # IFS
13324 # We need space, tab and new line, in precisely that order.
13325 as_nl='
13326 '
13327 IFS="   $as_nl"
13328
13329 # CDPATH.
13330 $as_unset CDPATH
13331
13332 exec 6>&1
13333
13334 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13335 # report actual input values of CONFIG_FILES etc. instead of their
13336 # values after options handling.  Logging --version etc. is OK.
13337 exec 5>>config.log
13338 {
13339   echo
13340   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13341 ## Running $as_me. ##
13342 _ASBOX
13343 } >&5
13344 cat >&5 <<_CSEOF
13345
13346 This file was extended by $as_me, which was
13347 generated by GNU Autoconf 2.59.  Invocation command line was
13348
13349   CONFIG_FILES    = $CONFIG_FILES
13350   CONFIG_HEADERS  = $CONFIG_HEADERS
13351   CONFIG_LINKS    = $CONFIG_LINKS
13352   CONFIG_COMMANDS = $CONFIG_COMMANDS
13353   $ $0 $@
13354
13355 _CSEOF
13356 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13357 echo >&5
13358 _ACEOF
13359
13360 # Files that config.status was made for.
13361 if test -n "$ac_config_files"; then
13362   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13363 fi
13364
13365 if test -n "$ac_config_headers"; then
13366   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13367 fi
13368
13369 if test -n "$ac_config_links"; then
13370   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13371 fi
13372
13373 if test -n "$ac_config_commands"; then
13374   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13375 fi
13376
13377 cat >>$CONFIG_STATUS <<\_ACEOF
13378
13379 ac_cs_usage="\
13380 \`$as_me' instantiates files from templates according to the
13381 current configuration.
13382
13383 Usage: $0 [OPTIONS] [FILE]...
13384
13385   -h, --help       print this help, then exit
13386   -V, --version    print version number, then exit
13387   -q, --quiet      do not print progress messages
13388   -d, --debug      don't remove temporary files
13389       --recheck    update $as_me by reconfiguring in the same conditions
13390   --file=FILE[:TEMPLATE]
13391                    instantiate the configuration file FILE
13392
13393 Configuration files:
13394 $config_files
13395
13396 Report bugs to <bug-autoconf@gnu.org>."
13397 _ACEOF
13398
13399 cat >>$CONFIG_STATUS <<_ACEOF
13400 ac_cs_version="\\
13401 config.status
13402 configured by $0, generated by GNU Autoconf 2.59,
13403   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13404
13405 Copyright (C) 2003 Free Software Foundation, Inc.
13406 This config.status script is free software; the Free Software Foundation
13407 gives unlimited permission to copy, distribute and modify it."
13408 srcdir=$srcdir
13409 INSTALL="$INSTALL"
13410 _ACEOF
13411
13412 cat >>$CONFIG_STATUS <<\_ACEOF
13413 # If no file are specified by the user, then we need to provide default
13414 # value.  By we need to know if files were specified by the user.
13415 ac_need_defaults=:
13416 while test $# != 0
13417 do
13418   case $1 in
13419   --*=*)
13420     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13421     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13422     ac_shift=:
13423     ;;
13424   -*)
13425     ac_option=$1
13426     ac_optarg=$2
13427     ac_shift=shift
13428     ;;
13429   *) # This is not an option, so the user has probably given explicit
13430      # arguments.
13431      ac_option=$1
13432      ac_need_defaults=false;;
13433   esac
13434
13435   case $ac_option in
13436   # Handling of the options.
13437 _ACEOF
13438 cat >>$CONFIG_STATUS <<\_ACEOF
13439   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13440     ac_cs_recheck=: ;;
13441   --version | --vers* | -V )
13442     echo "$ac_cs_version"; exit 0 ;;
13443   --he | --h)
13444     # Conflict between --help and --header
13445     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13446 Try \`$0 --help' for more information." >&5
13447 echo "$as_me: error: ambiguous option: $1
13448 Try \`$0 --help' for more information." >&2;}
13449    { (exit 1); exit 1; }; };;
13450   --help | --hel | -h )
13451     echo "$ac_cs_usage"; exit 0 ;;
13452   --debug | --d* | -d )
13453     debug=: ;;
13454   --file | --fil | --fi | --f )
13455     $ac_shift
13456     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13457     ac_need_defaults=false;;
13458   --header | --heade | --head | --hea )
13459     $ac_shift
13460     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13461     ac_need_defaults=false;;
13462   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13463   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13464     ac_cs_silent=: ;;
13465
13466   # This is an error.
13467   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13468 Try \`$0 --help' for more information." >&5
13469 echo "$as_me: error: unrecognized option: $1
13470 Try \`$0 --help' for more information." >&2;}
13471    { (exit 1); exit 1; }; } ;;
13472
13473   *) ac_config_targets="$ac_config_targets $1" ;;
13474
13475   esac
13476   shift
13477 done
13478
13479 ac_configure_extra_args=
13480
13481 if $ac_cs_silent; then
13482   exec 6>/dev/null
13483   ac_configure_extra_args="$ac_configure_extra_args --silent"
13484 fi
13485
13486 _ACEOF
13487 cat >>$CONFIG_STATUS <<_ACEOF
13488 if \$ac_cs_recheck; then
13489   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13490   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13491 fi
13492
13493 _ACEOF
13494
13495
13496
13497
13498
13499 cat >>$CONFIG_STATUS <<\_ACEOF
13500 for ac_config_target in $ac_config_targets
13501 do
13502   case "$ac_config_target" in
13503   # Handling of arguments.
13504   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13505   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13506 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13507    { (exit 1); exit 1; }; };;
13508   esac
13509 done
13510
13511 # If the user did not use the arguments to specify the items to instantiate,
13512 # then the envvar interface is used.  Set only those that are not.
13513 # We use the long form for the default assignment because of an extremely
13514 # bizarre bug on SunOS 4.1.3.
13515 if $ac_need_defaults; then
13516   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13517 fi
13518
13519 # Have a temporary directory for convenience.  Make it in the build tree
13520 # simply because there is no reason to put it here, and in addition,
13521 # creating and moving files from /tmp can sometimes cause problems.
13522 # Create a temporary directory, and hook for its removal unless debugging.
13523 $debug ||
13524 {
13525   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13526   trap '{ (exit 1); exit 1; }' 1 2 13 15
13527 }
13528
13529 # Create a (secure) tmp directory for tmp files.
13530
13531 {
13532   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13533   test -n "$tmp" && test -d "$tmp"
13534 }  ||
13535 {
13536   tmp=./confstat$$-$RANDOM
13537   (umask 077 && mkdir $tmp)
13538 } ||
13539 {
13540    echo "$me: cannot create a temporary directory in ." >&2
13541    { (exit 1); exit 1; }
13542 }
13543
13544 _ACEOF
13545
13546 cat >>$CONFIG_STATUS <<_ACEOF
13547
13548 #
13549 # CONFIG_FILES section.
13550 #
13551
13552 # No need to generate the scripts if there are no CONFIG_FILES.
13553 # This happens for instance when ./config.status config.h
13554 if test -n "\$CONFIG_FILES"; then
13555   # Protect against being on the right side of a sed subst in config.status.
13556   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13557    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13558 s,@SHELL@,$SHELL,;t t
13559 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13560 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13561 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13562 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13563 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13564 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13565 s,@exec_prefix@,$exec_prefix,;t t
13566 s,@prefix@,$prefix,;t t
13567 s,@program_transform_name@,$program_transform_name,;t t
13568 s,@bindir@,$bindir,;t t
13569 s,@sbindir@,$sbindir,;t t
13570 s,@libexecdir@,$libexecdir,;t t
13571 s,@datadir@,$datadir,;t t
13572 s,@sysconfdir@,$sysconfdir,;t t
13573 s,@sharedstatedir@,$sharedstatedir,;t t
13574 s,@localstatedir@,$localstatedir,;t t
13575 s,@libdir@,$libdir,;t t
13576 s,@includedir@,$includedir,;t t
13577 s,@oldincludedir@,$oldincludedir,;t t
13578 s,@infodir@,$infodir,;t t
13579 s,@mandir@,$mandir,;t t
13580 s,@build_alias@,$build_alias,;t t
13581 s,@host_alias@,$host_alias,;t t
13582 s,@target_alias@,$target_alias,;t t
13583 s,@DEFS@,$DEFS,;t t
13584 s,@ECHO_C@,$ECHO_C,;t t
13585 s,@ECHO_N@,$ECHO_N,;t t
13586 s,@ECHO_T@,$ECHO_T,;t t
13587 s,@LIBS@,$LIBS,;t t
13588 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13589 s,@build@,$build,;t t
13590 s,@build_cpu@,$build_cpu,;t t
13591 s,@build_vendor@,$build_vendor,;t t
13592 s,@build_os@,$build_os,;t t
13593 s,@build_noncanonical@,$build_noncanonical,;t t
13594 s,@host_noncanonical@,$host_noncanonical,;t t
13595 s,@target_noncanonical@,$target_noncanonical,;t t
13596 s,@host@,$host,;t t
13597 s,@host_cpu@,$host_cpu,;t t
13598 s,@host_vendor@,$host_vendor,;t t
13599 s,@host_os@,$host_os,;t t
13600 s,@target@,$target,;t t
13601 s,@target_cpu@,$target_cpu,;t t
13602 s,@target_vendor@,$target_vendor,;t t
13603 s,@target_os@,$target_os,;t t
13604 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13605 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13606 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13607 s,@LN@,$LN,;t t
13608 s,@LN_S@,$LN_S,;t t
13609 s,@build_libsubdir@,$build_libsubdir,;t t
13610 s,@build_subdir@,$build_subdir,;t t
13611 s,@host_subdir@,$host_subdir,;t t
13612 s,@target_subdir@,$target_subdir,;t t
13613 s,@CC@,$CC,;t t
13614 s,@CFLAGS@,$CFLAGS,;t t
13615 s,@LDFLAGS@,$LDFLAGS,;t t
13616 s,@CPPFLAGS@,$CPPFLAGS,;t t
13617 s,@ac_ct_CC@,$ac_ct_CC,;t t
13618 s,@EXEEXT@,$EXEEXT,;t t
13619 s,@OBJEXT@,$OBJEXT,;t t
13620 s,@CXX@,$CXX,;t t
13621 s,@CXXFLAGS@,$CXXFLAGS,;t t
13622 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13623 s,@GNATBIND@,$GNATBIND,;t t
13624 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13625 s,@GNATMAKE@,$GNATMAKE,;t t
13626 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13627 s,@do_compare@,$do_compare,;t t
13628 s,@gmplibs@,$gmplibs,;t t
13629 s,@gmpinc@,$gmpinc,;t t
13630 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13631 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13632 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13633 s,@stage1_ldflags@,$stage1_ldflags,;t t
13634 s,@stage1_libs@,$stage1_libs,;t t
13635 s,@poststage1_ldflags@,$poststage1_ldflags,;t t
13636 s,@poststage1_libs@,$poststage1_libs,;t t
13637 s,@ppllibs@,$ppllibs,;t t
13638 s,@pplinc@,$pplinc,;t t
13639 s,@clooglibs@,$clooglibs,;t t
13640 s,@clooginc@,$clooginc,;t t
13641 s,@stage1_languages@,$stage1_languages,;t t
13642 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13643 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13644 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13645 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13646 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13647 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13648 s,@tooldir@,$tooldir,;t t
13649 s,@build_tooldir@,$build_tooldir,;t t
13650 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13651 s,@GDB_TK@,$GDB_TK,;t t
13652 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13653 s,@build_configargs@,$build_configargs,;t t
13654 s,@build_configdirs@,$build_configdirs,;t t
13655 s,@host_configargs@,$host_configargs,;t t
13656 s,@configdirs@,$configdirs,;t t
13657 s,@target_configargs@,$target_configargs,;t t
13658 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13659 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13660 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13661 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13662 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13663 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13664 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13665 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13666 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13667 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13668 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13669 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13670 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13671 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13672 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13673 s,@config_shell@,$config_shell,;t t
13674 s,@YACC@,$YACC,;t t
13675 s,@BISON@,$BISON,;t t
13676 s,@M4@,$M4,;t t
13677 s,@LEX@,$LEX,;t t
13678 s,@FLEX@,$FLEX,;t t
13679 s,@MAKEINFO@,$MAKEINFO,;t t
13680 s,@EXPECT@,$EXPECT,;t t
13681 s,@RUNTEST@,$RUNTEST,;t t
13682 s,@AR@,$AR,;t t
13683 s,@AS@,$AS,;t t
13684 s,@DLLTOOL@,$DLLTOOL,;t t
13685 s,@LD@,$LD,;t t
13686 s,@LIPO@,$LIPO,;t t
13687 s,@NM@,$NM,;t t
13688 s,@RANLIB@,$RANLIB,;t t
13689 s,@STRIP@,$STRIP,;t t
13690 s,@WINDRES@,$WINDRES,;t t
13691 s,@WINDMC@,$WINDMC,;t t
13692 s,@OBJCOPY@,$OBJCOPY,;t t
13693 s,@OBJDUMP@,$OBJDUMP,;t t
13694 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13695 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13696 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13697 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13698 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13699 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13700 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13701 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13702 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13703 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13704 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13705 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13706 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13707 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13708 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13709 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13710 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13711 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13712 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13713 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13714 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13715 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13716 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13717 s,@MAINT@,$MAINT,;t t
13718 s,@stage1_cflags@,$stage1_cflags,;t t
13719 s,@stage1_checking@,$stage1_checking,;t t
13720 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13721 s,@datarootdir@,$datarootdir,;t t
13722 s,@docdir@,$docdir,;t t
13723 s,@pdfdir@,$pdfdir,;t t
13724 s,@htmldir@,$htmldir,;t t
13725 s,@compare_exclusions@,$compare_exclusions,;t t
13726 s,@LIBOBJS@,$LIBOBJS,;t t
13727 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13728 /@serialization_dependencies@/r $serialization_dependencies
13729 s,@serialization_dependencies@,,;t t
13730 /@host_makefile_frag@/r $host_makefile_frag
13731 s,@host_makefile_frag@,,;t t
13732 /@target_makefile_frag@/r $target_makefile_frag
13733 s,@target_makefile_frag@,,;t t
13734 /@alphaieee_frag@/r $alphaieee_frag
13735 s,@alphaieee_frag@,,;t t
13736 /@ospace_frag@/r $ospace_frag
13737 s,@ospace_frag@,,;t t
13738 CEOF
13739
13740 _ACEOF
13741
13742   cat >>$CONFIG_STATUS <<\_ACEOF
13743   # Split the substitutions into bite-sized pieces for seds with
13744   # small command number limits, like on Digital OSF/1 and HP-UX.
13745   ac_max_sed_lines=48
13746   ac_sed_frag=1 # Number of current file.
13747   ac_beg=1 # First line for current file.
13748   ac_end=$ac_max_sed_lines # Line after last line for current file.
13749   ac_more_lines=:
13750   ac_sed_cmds=
13751   while $ac_more_lines; do
13752     if test $ac_beg -gt 1; then
13753       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13754     else
13755       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13756     fi
13757     if test ! -s $tmp/subs.frag; then
13758       ac_more_lines=false
13759     else
13760       # The purpose of the label and of the branching condition is to
13761       # speed up the sed processing (if there are no `@' at all, there
13762       # is no need to browse any of the substitutions).
13763       # These are the two extra sed commands mentioned above.
13764       (echo ':t
13765   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13766       if test -z "$ac_sed_cmds"; then
13767         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13768       else
13769         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13770       fi
13771       ac_sed_frag=`expr $ac_sed_frag + 1`
13772       ac_beg=$ac_end
13773       ac_end=`expr $ac_end + $ac_max_sed_lines`
13774     fi
13775   done
13776   if test -z "$ac_sed_cmds"; then
13777     ac_sed_cmds=cat
13778   fi
13779 fi # test -n "$CONFIG_FILES"
13780
13781 _ACEOF
13782 cat >>$CONFIG_STATUS <<\_ACEOF
13783 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13784   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13785   case $ac_file in
13786   - | *:- | *:-:* ) # input from stdin
13787         cat >$tmp/stdin
13788         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13789         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13790   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13791         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13792   * )   ac_file_in=$ac_file.in ;;
13793   esac
13794
13795   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13796   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13797 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13798          X"$ac_file" : 'X\(//\)[^/]' \| \
13799          X"$ac_file" : 'X\(//\)$' \| \
13800          X"$ac_file" : 'X\(/\)' \| \
13801          .     : '\(.\)' 2>/dev/null ||
13802 echo X"$ac_file" |
13803     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13804           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13805           /^X\(\/\/\)$/{ s//\1/; q; }
13806           /^X\(\/\).*/{ s//\1/; q; }
13807           s/.*/./; q'`
13808   { if $as_mkdir_p; then
13809     mkdir -p "$ac_dir"
13810   else
13811     as_dir="$ac_dir"
13812     as_dirs=
13813     while test ! -d "$as_dir"; do
13814       as_dirs="$as_dir $as_dirs"
13815       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13816 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13817          X"$as_dir" : 'X\(//\)[^/]' \| \
13818          X"$as_dir" : 'X\(//\)$' \| \
13819          X"$as_dir" : 'X\(/\)' \| \
13820          .     : '\(.\)' 2>/dev/null ||
13821 echo X"$as_dir" |
13822     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13823           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13824           /^X\(\/\/\)$/{ s//\1/; q; }
13825           /^X\(\/\).*/{ s//\1/; q; }
13826           s/.*/./; q'`
13827     done
13828     test ! -n "$as_dirs" || mkdir $as_dirs
13829   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13830 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13831    { (exit 1); exit 1; }; }; }
13832
13833   ac_builddir=.
13834
13835 if test "$ac_dir" != .; then
13836   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13837   # A "../" for each directory in $ac_dir_suffix.
13838   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13839 else
13840   ac_dir_suffix= ac_top_builddir=
13841 fi
13842
13843 case $srcdir in
13844   .)  # No --srcdir option.  We are building in place.
13845     ac_srcdir=.
13846     if test -z "$ac_top_builddir"; then
13847        ac_top_srcdir=.
13848     else
13849        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13850     fi ;;
13851   [\\/]* | ?:[\\/]* )  # Absolute path.
13852     ac_srcdir=$srcdir$ac_dir_suffix;
13853     ac_top_srcdir=$srcdir ;;
13854   *) # Relative path.
13855     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13856     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13857 esac
13858
13859 # Do not use `cd foo && pwd` to compute absolute paths, because
13860 # the directories may not exist.
13861 case `pwd` in
13862 .) ac_abs_builddir="$ac_dir";;
13863 *)
13864   case "$ac_dir" in
13865   .) ac_abs_builddir=`pwd`;;
13866   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13867   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13868   esac;;
13869 esac
13870 case $ac_abs_builddir in
13871 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13872 *)
13873   case ${ac_top_builddir}. in
13874   .) ac_abs_top_builddir=$ac_abs_builddir;;
13875   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13876   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13877   esac;;
13878 esac
13879 case $ac_abs_builddir in
13880 .) ac_abs_srcdir=$ac_srcdir;;
13881 *)
13882   case $ac_srcdir in
13883   .) ac_abs_srcdir=$ac_abs_builddir;;
13884   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13885   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13886   esac;;
13887 esac
13888 case $ac_abs_builddir in
13889 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13890 *)
13891   case $ac_top_srcdir in
13892   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13893   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13894   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13895   esac;;
13896 esac
13897
13898
13899   case $INSTALL in
13900   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13901   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13902   esac
13903
13904   if test x"$ac_file" != x-; then
13905     { echo "$as_me:$LINENO: creating $ac_file" >&5
13906 echo "$as_me: creating $ac_file" >&6;}
13907     rm -f "$ac_file"
13908   fi
13909   # Let's still pretend it is `configure' which instantiates (i.e., don't
13910   # use $as_me), people would be surprised to read:
13911   #    /* config.h.  Generated by config.status.  */
13912   if test x"$ac_file" = x-; then
13913     configure_input=
13914   else
13915     configure_input="$ac_file.  "
13916   fi
13917   configure_input=$configure_input"Generated from `echo $ac_file_in |
13918                                      sed 's,.*/,,'` by configure."
13919
13920   # First look for the input files in the build tree, otherwise in the
13921   # src tree.
13922   ac_file_inputs=`IFS=:
13923     for f in $ac_file_in; do
13924       case $f in
13925       -) echo $tmp/stdin ;;
13926       [\\/$]*)
13927          # Absolute (can't be DOS-style, as IFS=:)
13928          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13929 echo "$as_me: error: cannot find input file: $f" >&2;}
13930    { (exit 1); exit 1; }; }
13931          echo "$f";;
13932       *) # Relative
13933          if test -f "$f"; then
13934            # Build tree
13935            echo "$f"
13936          elif test -f "$srcdir/$f"; then
13937            # Source tree
13938            echo "$srcdir/$f"
13939          else
13940            # /dev/null tree
13941            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13942 echo "$as_me: error: cannot find input file: $f" >&2;}
13943    { (exit 1); exit 1; }; }
13944          fi;;
13945       esac
13946     done` || { (exit 1); exit 1; }
13947 _ACEOF
13948 cat >>$CONFIG_STATUS <<_ACEOF
13949   sed "$ac_vpsub
13950 $extrasub
13951 _ACEOF
13952 cat >>$CONFIG_STATUS <<\_ACEOF
13953 :t
13954 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13955 s,@configure_input@,$configure_input,;t t
13956 s,@srcdir@,$ac_srcdir,;t t
13957 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13958 s,@top_srcdir@,$ac_top_srcdir,;t t
13959 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13960 s,@builddir@,$ac_builddir,;t t
13961 s,@abs_builddir@,$ac_abs_builddir,;t t
13962 s,@top_builddir@,$ac_top_builddir,;t t
13963 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13964 s,@INSTALL@,$ac_INSTALL,;t t
13965 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13966   rm -f $tmp/stdin
13967   if test x"$ac_file" != x-; then
13968     mv $tmp/out $ac_file
13969   else
13970     cat $tmp/out
13971     rm -f $tmp/out
13972   fi
13973
13974 done
13975 _ACEOF
13976
13977 cat >>$CONFIG_STATUS <<\_ACEOF
13978
13979 { (exit 0); exit 0; }
13980 _ACEOF
13981 chmod +x $CONFIG_STATUS
13982 ac_clean_files=$ac_clean_files_save
13983
13984
13985 # configure is writing to config.log, and then calls config.status.
13986 # config.status does its own redirection, appending to config.log.
13987 # Unfortunately, on DOS this fails, as config.log is still kept open
13988 # by configure, so config.status won't be able to write to it; its
13989 # output is simply discarded.  So we exec the FD to /dev/null,
13990 # effectively closing config.log, so it can be properly (re)opened and
13991 # appended to by config.status.  When coming back to configure, we
13992 # need to make the FD available again.
13993 if test "$no_create" != yes; then
13994   ac_cs_success=:
13995   ac_config_status_args=
13996   test "$silent" = yes &&
13997     ac_config_status_args="$ac_config_status_args --quiet"
13998   exec 5>/dev/null
13999   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
14000   exec 5>>config.log
14001   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
14002   # would make configure fail if this is the last instruction.
14003   $ac_cs_success || { (exit 1); exit 1; }
14004 fi
14005