configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc extra_mpfr_configure_flags extra_mpc_gmp_configure_flags extra_mpc_mpfr_configure_flags stage1_ldflags stage1_libs poststage1_ldflags poststage1_libs ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir compare_exclusions LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-build-with-cxx build with C++ compiler instead of C compiler
 939   --disable-ppl-version-check    disable check for PPL version
 940   --disable-cloog-version-check  disable check for CLooG version
 941   --enable-stage1-languages[=all]   choose additional languages to build during
 942                           stage1.  Mostly useful for compiler development.
 943   --enable-objc-gc        enable use of Boehm's garbage collector with the
 944                           GNU Objective-C runtime
 945   --enable-bootstrap      enable bootstrapping [yes if native build]
 946   --enable-serial-[{host,target,build}-]configure
 947                           force sequential configuration of
 948                           sub-packages for the host, target or build
 949                           machine, or all sub-packages
 950   --enable-maintainer-mode enable make rules and dependencies not useful
 951                           (and sometimes confusing) to the casual installer
 952   --enable-stage1-checking[=all]   choose additional checking for stage1
 953                           of the compiler
 954   --enable-werror         enable -Werror in bootstrap stage2 and later
 955
 956 Optional Packages:
 957   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 958   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 959   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 960   --with-mpc=PATH        specify prefix directory for installed MPC package.
 961                           Equivalent to --with-mpc-include=PATH/include
 962                           plus --with-mpc-lib=PATH/lib
 963   --with-mpc-include=PATH
 964                           specify directory for installed MPC include files
 965   --with-mpc-lib=PATH    specify directory for the installed MPC library
 966   --with-mpfr-dir=PATH    this option has been REMOVED
 967   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 968                           Equivalent to --with-mpfr-include=PATH/include
 969                           plus --with-mpfr-lib=PATH/lib
 970   --with-mpfr-include=PATH
 971                           specify directory for installed MPFR include files
 972   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 973   --with-gmp-dir=PATH     this option has been REMOVED
 974   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 975                           Equivalent to --with-gmp-include=PATH/include
 976                           plus --with-gmp-lib=PATH/lib
 977   --with-gmp-include=PATH specify directory for installed GMP include files
 978   --with-gmp-lib=PATH     specify directory for the installed GMP library
 979   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 980                           when linking with PPL
 981   --with-stage1-ldflags=FLAGS Linker flags for stage1
 982   -with-stage1-libs=LIBS      Libraries for stage1
 983   --with-boot-ldflags=FLAGS Linker flags for stage2 and later
 984   --with-boot-libs=LIBS     Libraries for stage2 and later
 985   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 986                           Equivalent to --with-ppl-include=PATH/include
 987                           plus --with-ppl-lib=PATH/lib
 988   --with-ppl-include=PATH Specify directory for installed PPL include files
 989   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 990   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 991                           Equivalent to --with-cloog-include=PATH/include
 992                           plus --with-cloog-lib=PATH/lib
 993   --with-cloog-include=PATH Specify directory for installed CLooG include files
 994   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 995   --with-build-sysroot=SYSROOT
 996                           use sysroot as the system root during the build
 997   --with-debug-prefix-map='A=B C=D ...'
 998                              map A to B, C to D ... in debug information
 999   --with-build-time-tools=PATH
1000                           use given path to find target tools during the build
1001   --with-datarootdir      use datarootdir as the data root directory.
1002   --with-docdir           install documentation in this directory.
1003   --with-pdfdir           install pdf in this directory.
1004   --with-htmldir          install html in this directory.
1005
1006 Some influential environment variables:
1007   CC          C compiler command
1008   CFLAGS      C compiler flags
1009   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1010               nonstandard directory <lib dir>
1011   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1012               headers in a nonstandard directory <include dir>
1013   CXX         C++ compiler command
1014   CXXFLAGS    C++ compiler flags
1015   AR          AR for the host
1016   AS          AS for the host
1017   DLLTOOL     DLLTOOL for the host
1018   LD          LD for the host
1019   LIPO        LIPO for the host
1020   NM          NM for the host
1021   RANLIB      RANLIB for the host
1022   STRIP       STRIP for the host
1023   WINDRES     WINDRES for the host
1024   WINDMC      WINDMC for the host
1025   OBJCOPY     OBJCOPY for the host
1026   OBJDUMP     OBJDUMP for the host
1027   CC_FOR_TARGET
1028               CC for the target
1029   CXX_FOR_TARGET
1030               CXX for the target
1031   GCC_FOR_TARGET
1032               GCC for the target
1033   GCJ_FOR_TARGET
1034               GCJ for the target
1035   GFORTRAN_FOR_TARGET
1036               GFORTRAN for the target
1037   AR_FOR_TARGET
1038               AR for the target
1039   AS_FOR_TARGET
1040               AS for the target
1041   DLLTOOL_FOR_TARGET
1042               DLLTOOL for the target
1043   LD_FOR_TARGET
1044               LD for the target
1045   LIPO_FOR_TARGET
1046               LIPO for the target
1047   NM_FOR_TARGET
1048               NM for the target
1049   OBJDUMP_FOR_TARGET
1050               OBJDUMP for the target
1051   RANLIB_FOR_TARGET
1052               RANLIB for the target
1053   STRIP_FOR_TARGET
1054               STRIP for the target
1055   WINDRES_FOR_TARGET
1056               WINDRES for the target
1057   WINDMC_FOR_TARGET
1058               WINDMC for the target
1059
1060 Use these variables to override the choices made by `configure' or to help
1061 it to find libraries and programs with nonstandard names/locations.
1062
1063 _ACEOF
1064 fi
1065
1066 if test "$ac_init_help" = "recursive"; then
1067   # If there are subdirs, report their specific --help.
1068   ac_popdir=`pwd`
1069   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1070     test -d $ac_dir || continue
1071     ac_builddir=.
1072
1073 if test "$ac_dir" != .; then
1074   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1075   # A "../" for each directory in $ac_dir_suffix.
1076   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1077 else
1078   ac_dir_suffix= ac_top_builddir=
1079 fi
1080
1081 case $srcdir in
1082   .)  # No --srcdir option.  We are building in place.
1083     ac_srcdir=.
1084     if test -z "$ac_top_builddir"; then
1085        ac_top_srcdir=.
1086     else
1087        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1088     fi ;;
1089   [\\/]* | ?:[\\/]* )  # Absolute path.
1090     ac_srcdir=$srcdir$ac_dir_suffix;
1091     ac_top_srcdir=$srcdir ;;
1092   *) # Relative path.
1093     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1094     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1095 esac
1096
1097 # Do not use `cd foo && pwd` to compute absolute paths, because
1098 # the directories may not exist.
1099 case `pwd` in
1100 .) ac_abs_builddir="$ac_dir";;
1101 *)
1102   case "$ac_dir" in
1103   .) ac_abs_builddir=`pwd`;;
1104   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1105   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1106   esac;;
1107 esac
1108 case $ac_abs_builddir in
1109 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1110 *)
1111   case ${ac_top_builddir}. in
1112   .) ac_abs_top_builddir=$ac_abs_builddir;;
1113   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1114   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1115   esac;;
1116 esac
1117 case $ac_abs_builddir in
1118 .) ac_abs_srcdir=$ac_srcdir;;
1119 *)
1120   case $ac_srcdir in
1121   .) ac_abs_srcdir=$ac_abs_builddir;;
1122   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1123   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1124   esac;;
1125 esac
1126 case $ac_abs_builddir in
1127 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1128 *)
1129   case $ac_top_srcdir in
1130   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1131   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1132   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1133   esac;;
1134 esac
1135
1136     cd $ac_dir
1137     # Check for guested configure; otherwise get Cygnus style configure.
1138     if test -f $ac_srcdir/configure.gnu; then
1139       echo
1140       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1141     elif test -f $ac_srcdir/configure; then
1142       echo
1143       $SHELL $ac_srcdir/configure  --help=recursive
1144     elif test -f $ac_srcdir/configure.ac ||
1145            test -f $ac_srcdir/configure.in; then
1146       echo
1147       $ac_configure --help
1148     else
1149       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1150     fi
1151     cd $ac_popdir
1152   done
1153 fi
1154
1155 test -n "$ac_init_help" && exit 0
1156 if $ac_init_version; then
1157   cat <<\_ACEOF
1158
1159 Copyright (C) 2003 Free Software Foundation, Inc.
1160 This configure script is free software; the Free Software Foundation
1161 gives unlimited permission to copy, distribute and modify it.
1162 _ACEOF
1163   exit 0
1164 fi
1165 exec 5>config.log
1166 cat >&5 <<_ACEOF
1167 This file contains any messages produced by compilers while
1168 running configure, to aid debugging if configure makes a mistake.
1169
1170 It was created by $as_me, which was
1171 generated by GNU Autoconf 2.59.  Invocation command line was
1172
1173   $ $0 $@
1174
1175 _ACEOF
1176 {
1177 cat <<_ASUNAME
1178 ## --------- ##
1179 ## Platform. ##
1180 ## --------- ##
1181
1182 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1183 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1184 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1185 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1186 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1187
1188 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1189 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1190
1191 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1192 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1193 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1194 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1195 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1196 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1197 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1198
1199 _ASUNAME
1200
1201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1202 for as_dir in $PATH
1203 do
1204   IFS=$as_save_IFS
1205   test -z "$as_dir" && as_dir=.
1206   echo "PATH: $as_dir"
1207 done
1208
1209 } >&5
1210
1211 cat >&5 <<_ACEOF
1212
1213
1214 ## ----------- ##
1215 ## Core tests. ##
1216 ## ----------- ##
1217
1218 _ACEOF
1219
1220
1221 # Keep a trace of the command line.
1222 # Strip out --no-create and --no-recursion so they do not pile up.
1223 # Strip out --silent because we don't want to record it for future runs.
1224 # Also quote any args containing shell meta-characters.
1225 # Make two passes to allow for proper duplicate-argument suppression.
1226 ac_configure_args=
1227 ac_configure_args0=
1228 ac_configure_args1=
1229 ac_sep=
1230 ac_must_keep_next=false
1231 for ac_pass in 1 2
1232 do
1233   for ac_arg
1234   do
1235     case $ac_arg in
1236     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1237     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1238     | -silent | --silent | --silen | --sile | --sil)
1239       continue ;;
1240     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1241       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1242     esac
1243     case $ac_pass in
1244     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1245     2)
1246       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1247       if test $ac_must_keep_next = true; then
1248         ac_must_keep_next=false # Got value, back to normal.
1249       else
1250         case $ac_arg in
1251           *=* | --config-cache | -C | -disable-* | --disable-* \
1252           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1253           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1254           | -with-* | --with-* | -without-* | --without-* | --x)
1255             case "$ac_configure_args0 " in
1256               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1257             esac
1258             ;;
1259           -* ) ac_must_keep_next=true ;;
1260         esac
1261       fi
1262       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1263       # Get rid of the leading space.
1264       ac_sep=" "
1265       ;;
1266     esac
1267   done
1268 done
1269 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1270 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1271
1272 # When interrupted or exit'd, cleanup temporary files, and complete
1273 # config.log.  We remove comments because anyway the quotes in there
1274 # would cause problems or look ugly.
1275 # WARNING: Be sure not to use single quotes in there, as some shells,
1276 # such as our DU 5.0 friend, will then `close' the trap.
1277 trap 'exit_status=$?
1278   # Save into config.log some information that might help in debugging.
1279   {
1280     echo
1281
1282     cat <<\_ASBOX
1283 ## ---------------- ##
1284 ## Cache variables. ##
1285 ## ---------------- ##
1286 _ASBOX
1287     echo
1288     # The following way of writing the cache mishandles newlines in values,
1289 {
1290   (set) 2>&1 |
1291     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1292     *ac_space=\ *)
1293       sed -n \
1294         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1295           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1296       ;;
1297     *)
1298       sed -n \
1299         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1300       ;;
1301     esac;
1302 }
1303     echo
1304
1305     cat <<\_ASBOX
1306 ## ----------------- ##
1307 ## Output variables. ##
1308 ## ----------------- ##
1309 _ASBOX
1310     echo
1311     for ac_var in $ac_subst_vars
1312     do
1313       eval ac_val=$`echo $ac_var`
1314       echo "$ac_var='"'"'$ac_val'"'"'"
1315     done | sort
1316     echo
1317
1318     if test -n "$ac_subst_files"; then
1319       cat <<\_ASBOX
1320 ## ------------- ##
1321 ## Output files. ##
1322 ## ------------- ##
1323 _ASBOX
1324       echo
1325       for ac_var in $ac_subst_files
1326       do
1327         eval ac_val=$`echo $ac_var`
1328         echo "$ac_var='"'"'$ac_val'"'"'"
1329       done | sort
1330       echo
1331     fi
1332
1333     if test -s confdefs.h; then
1334       cat <<\_ASBOX
1335 ## ----------- ##
1336 ## confdefs.h. ##
1337 ## ----------- ##
1338 _ASBOX
1339       echo
1340       sed "/^$/d" confdefs.h | sort
1341       echo
1342     fi
1343     test "$ac_signal" != 0 &&
1344       echo "$as_me: caught signal $ac_signal"
1345     echo "$as_me: exit $exit_status"
1346   } >&5
1347   rm -f core *.core &&
1348   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1349     exit $exit_status
1350      ' 0
1351 for ac_signal in 1 2 13 15; do
1352   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1353 done
1354 ac_signal=0
1355
1356 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1357 rm -rf conftest* confdefs.h
1358 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1359 echo >confdefs.h
1360
1361 # Predefined preprocessor variables.
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_NAME "$PACKAGE_NAME"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_STRING "$PACKAGE_STRING"
1380 _ACEOF
1381
1382
1383 cat >>confdefs.h <<_ACEOF
1384 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1385 _ACEOF
1386
1387
1388 # Let the site file select an alternate cache file if it wants to.
1389 # Prefer explicitly selected file to automatically selected ones.
1390 if test -z "$CONFIG_SITE"; then
1391   if test "x$prefix" != xNONE; then
1392     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1393   else
1394     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1395   fi
1396 fi
1397 for ac_site_file in $CONFIG_SITE; do
1398   if test -r "$ac_site_file"; then
1399     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1400 echo "$as_me: loading site script $ac_site_file" >&6;}
1401     sed 's/^/| /' "$ac_site_file" >&5
1402     . "$ac_site_file"
1403   fi
1404 done
1405
1406 if test -r "$cache_file"; then
1407   # Some versions of bash will fail to source /dev/null (special
1408   # files actually), so we avoid doing that.
1409   if test -f "$cache_file"; then
1410     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1411 echo "$as_me: loading cache $cache_file" >&6;}
1412     case $cache_file in
1413       [\\/]* | ?:[\\/]* ) . $cache_file;;
1414       *)                      . ./$cache_file;;
1415     esac
1416   fi
1417 else
1418   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1419 echo "$as_me: creating cache $cache_file" >&6;}
1420   >$cache_file
1421 fi
1422
1423 # Check that the precious variables saved in the cache have kept the same
1424 # value.
1425 ac_cache_corrupted=false
1426 for ac_var in `(set) 2>&1 |
1427                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1428   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1429   eval ac_new_set=\$ac_env_${ac_var}_set
1430   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1431   eval ac_new_val="\$ac_env_${ac_var}_value"
1432   case $ac_old_set,$ac_new_set in
1433     set,)
1434       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1435 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1436       ac_cache_corrupted=: ;;
1437     ,set)
1438       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1439 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1440       ac_cache_corrupted=: ;;
1441     ,);;
1442     *)
1443       if test "x$ac_old_val" != "x$ac_new_val"; then
1444         # differences in whitespace do not lead to failure.
1445         ac_old_val_w=`echo x $ac_old_val`
1446         ac_new_val_w=`echo x $ac_new_val`
1447         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1448           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1449 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1450           ac_cache_corrupted=:
1451         else
1452           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1453 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1454           eval $ac_var=\$ac_old_val
1455         fi
1456         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1457 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1458         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1459 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1460       fi;;
1461   esac
1462   # Pass precious variables to config.status.
1463   if test "$ac_new_set" = set; then
1464     case $ac_new_val in
1465     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1466       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1467     *) ac_arg=$ac_var=$ac_new_val ;;
1468     esac
1469     case " $ac_configure_args " in
1470       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1471       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1472     esac
1473   fi
1474 done
1475 if $ac_cache_corrupted; then
1476   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1477 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1478   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1479 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1480   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1481 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1482    { (exit 1); exit 1; }; }
1483 fi
1484
1485 ac_ext=c
1486 ac_cpp='$CPP $CPPFLAGS'
1487 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1488 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1489 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514 progname=$0
1515 # if PWD already has a value, it is probably wrong.
1516 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1517
1518 # Export original configure arguments for use by sub-configures.
1519 # Quote arguments with shell meta charatcers.
1520 TOPLEVEL_CONFIGURE_ARGUMENTS=
1521 set -- "$progname" "$@"
1522 for ac_arg
1523 do
1524   case "$ac_arg" in
1525   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1526     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1527     # if the argument is of the form -foo=baz, quote the baz part only
1528     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1529   *) ;;
1530   esac
1531   # Add the quoted argument to the list.
1532   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1533 done
1534 if test "$silent" = yes; then
1535   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1536 fi
1537 # Remove the initial space we just introduced and, as these will be
1538 # expanded by make, quote '$'.
1539 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1540
1541
1542 # Find the build, host, and target systems.
1543 ac_aux_dir=
1544 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1545   if test -f $ac_dir/install-sh; then
1546     ac_aux_dir=$ac_dir
1547     ac_install_sh="$ac_aux_dir/install-sh -c"
1548     break
1549   elif test -f $ac_dir/install.sh; then
1550     ac_aux_dir=$ac_dir
1551     ac_install_sh="$ac_aux_dir/install.sh -c"
1552     break
1553   elif test -f $ac_dir/shtool; then
1554     ac_aux_dir=$ac_dir
1555     ac_install_sh="$ac_aux_dir/shtool install -c"
1556     break
1557   fi
1558 done
1559 if test -z "$ac_aux_dir"; then
1560   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1561 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1562    { (exit 1); exit 1; }; }
1563 fi
1564 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1565 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1566 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1567
1568 # Make sure we can run config.sub.
1569 $ac_config_sub sun4 >/dev/null 2>&1 ||
1570   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1571 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1572    { (exit 1); exit 1; }; }
1573
1574 echo "$as_me:$LINENO: checking build system type" >&5
1575 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1576 if test "${ac_cv_build+set}" = set; then
1577   echo $ECHO_N "(cached) $ECHO_C" >&6
1578 else
1579   ac_cv_build_alias=$build_alias
1580 test -z "$ac_cv_build_alias" &&
1581   ac_cv_build_alias=`$ac_config_guess`
1582 test -z "$ac_cv_build_alias" &&
1583   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1584 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1585    { (exit 1); exit 1; }; }
1586 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1593 echo "${ECHO_T}$ac_cv_build" >&6
1594 build=$ac_cv_build
1595 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600  case ${build_alias} in
1601   "") build_noncanonical=${build} ;;
1602   *) build_noncanonical=${build_alias} ;;
1603 esac
1604
1605
1606
1607  case ${host_alias} in
1608   "") host_noncanonical=${build_noncanonical} ;;
1609   *) host_noncanonical=${host_alias} ;;
1610 esac
1611
1612
1613
1614  case ${target_alias} in
1615   "") target_noncanonical=${host_noncanonical} ;;
1616   *) target_noncanonical=${target_alias} ;;
1617 esac
1618
1619
1620
1621
1622 test "$host_noncanonical" = "$target_noncanonical" &&
1623   test "$program_prefix$program_suffix$program_transform_name" = \
1624     NONENONEs,x,x, &&
1625   program_transform_name=s,y,y,
1626
1627 echo "$as_me:$LINENO: checking host system type" >&5
1628 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1629 if test "${ac_cv_host+set}" = set; then
1630   echo $ECHO_N "(cached) $ECHO_C" >&6
1631 else
1632   ac_cv_host_alias=$host_alias
1633 test -z "$ac_cv_host_alias" &&
1634   ac_cv_host_alias=$ac_cv_build_alias
1635 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1636   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1637 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1638    { (exit 1); exit 1; }; }
1639
1640 fi
1641 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1642 echo "${ECHO_T}$ac_cv_host" >&6
1643 host=$ac_cv_host
1644 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1645 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1646 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1647
1648
1649 echo "$as_me:$LINENO: checking target system type" >&5
1650 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1651 if test "${ac_cv_target+set}" = set; then
1652   echo $ECHO_N "(cached) $ECHO_C" >&6
1653 else
1654   ac_cv_target_alias=$target_alias
1655 test "x$ac_cv_target_alias" = "x" &&
1656   ac_cv_target_alias=$ac_cv_host_alias
1657 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1658   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1659 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1660    { (exit 1); exit 1; }; }
1661
1662 fi
1663 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1664 echo "${ECHO_T}$ac_cv_target" >&6
1665 target=$ac_cv_target
1666 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1667 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1668 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1669
1670
1671 # The aliases save the names the user supplied, while $host etc.
1672 # will get canonicalized.
1673 test -n "$target_alias" &&
1674   test "$program_prefix$program_suffix$program_transform_name" = \
1675     NONENONEs,x,x, &&
1676   program_prefix=${target_alias}-
1677 test "$program_prefix" != NONE &&
1678   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1679 # Use a double $ so make ignores it.
1680 test "$program_suffix" != NONE &&
1681   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1682 # Double any \ or $.  echo might interpret backslashes.
1683 # By default was `s,x,x', remove it if useless.
1684 cat <<\_ACEOF >conftest.sed
1685 s/[\\$]/&&/g;s/;s,x,x,$//
1686 _ACEOF
1687 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1688 rm conftest.sed
1689
1690
1691
1692 # Get 'install' or 'install-sh' and its variants.
1693 # Find a good install program.  We prefer a C program (faster),
1694 # so one script is as good as another.  But avoid the broken or
1695 # incompatible versions:
1696 # SysV /etc/install, /usr/sbin/install
1697 # SunOS /usr/etc/install
1698 # IRIX /sbin/install
1699 # AIX /bin/install
1700 # AmigaOS /C/install, which installs bootblocks on floppy discs
1701 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1702 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1703 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1704 # OS/2's system install, which has a completely different semantic
1705 # ./install, which can be erroneously created by make from ./install.sh.
1706 # Reject install programs that cannot install multiple files.
1707 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1708 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1709 if test -z "$INSTALL"; then
1710 if test "${ac_cv_path_install+set}" = set; then
1711   echo $ECHO_N "(cached) $ECHO_C" >&6
1712 else
1713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1714 for as_dir in $PATH
1715 do
1716   IFS=$as_save_IFS
1717   test -z "$as_dir" && as_dir=.
1718   # Account for people who put trailing slashes in PATH elements.
1719 case $as_dir/ in
1720   ./ | .// | /cC/* | \
1721   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1722   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1723   /usr/ucb/* ) ;;
1724   *)
1725     # OSF1 and SCO ODT 3.0 have their own names for install.
1726     # Don't use installbsd from OSF since it installs stuff as root
1727     # by default.
1728     for ac_prog in ginstall scoinst install; do
1729       for ac_exec_ext in '' $ac_executable_extensions; do
1730         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1731           if test $ac_prog = install &&
1732             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1733             # AIX install.  It has an incompatible calling convention.
1734             :
1735           elif test $ac_prog = install &&
1736             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1737             # program-specific install script used by HP pwplus--don't use.
1738             :
1739           else
1740             rm -rf conftest.one conftest.two conftest.dir
1741             echo one > conftest.one
1742             echo two > conftest.two
1743             mkdir conftest.dir
1744             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1745               test -s conftest.one && test -s conftest.two &&
1746               test -s conftest.dir/conftest.one &&
1747               test -s conftest.dir/conftest.two
1748             then
1749               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1750               break 3
1751             fi
1752           fi
1753         fi
1754       done
1755     done
1756     ;;
1757 esac
1758 done
1759
1760 rm -rf conftest.one conftest.two conftest.dir
1761
1762 fi
1763   if test "${ac_cv_path_install+set}" = set; then
1764     INSTALL=$ac_cv_path_install
1765   else
1766     # As a last resort, use the slow shell script.  Don't cache a
1767     # value for INSTALL within a source directory, because that will
1768     # break other packages using the cache if that directory is
1769     # removed, or if the value is a relative name.
1770     INSTALL=$ac_install_sh
1771   fi
1772 fi
1773 echo "$as_me:$LINENO: result: $INSTALL" >&5
1774 echo "${ECHO_T}$INSTALL" >&6
1775
1776 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1777 # It thinks the first close brace ends the variable substitution.
1778 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1779
1780 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1781
1782 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1783
1784 echo "$as_me:$LINENO: checking whether ln works" >&5
1785 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1786 if test "${acx_cv_prog_LN+set}" = set; then
1787   echo $ECHO_N "(cached) $ECHO_C" >&6
1788 else
1789   rm -f conftestdata_t
1790 echo >conftestdata_f
1791 if ln conftestdata_f conftestdata_t 2>/dev/null
1792 then
1793   acx_cv_prog_LN=ln
1794 else
1795   acx_cv_prog_LN=no
1796 fi
1797 rm -f conftestdata_f conftestdata_t
1798
1799 fi
1800 if test $acx_cv_prog_LN = no; then
1801   LN="cp"
1802   echo "$as_me:$LINENO: result: no, using $LN" >&5
1803 echo "${ECHO_T}no, using $LN" >&6
1804 else
1805   LN="$acx_cv_prog_LN"
1806   echo "$as_me:$LINENO: result: yes" >&5
1807 echo "${ECHO_T}yes" >&6
1808 fi
1809
1810 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1811 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1812 LN_S=$as_ln_s
1813 if test "$LN_S" = "ln -s"; then
1814   echo "$as_me:$LINENO: result: yes" >&5
1815 echo "${ECHO_T}yes" >&6
1816 else
1817   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1818 echo "${ECHO_T}no, using $LN_S" >&6
1819 fi
1820
1821
1822 ### we might need to use some other shell than /bin/sh for running subshells
1823 ### If we are on Windows, search for the shell.  This will permit people
1824 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1825 ### without also having to set CONFIG_SHELL.  This code will work when
1826 ### using bash, which sets OSTYPE.
1827 case "${OSTYPE}" in
1828 *win32*)
1829   if test x${CONFIG_SHELL} = x ; then
1830     if test ! -f /bin/sh ; then
1831       if test x${SHELL} != x && test -f ${SHELL} ; then
1832         CONFIG_SHELL=${SHELL}
1833         export CONFIG_SHELL
1834       else
1835         for prog in sh sh.exe bash bash.exe; do
1836           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1837           for dir in $PATH; do
1838             test -z "$dir" && dir=.
1839             if test -f $dir/$prog; then
1840               CONFIG_SHELL=$dir/$prog
1841               export CONFIG_SHELL
1842               break
1843             fi
1844           done
1845           IFS="$save_ifs"
1846           test -n "${CONFIG_SHELL}" && break
1847         done
1848       fi
1849     fi
1850   fi
1851   ;;
1852 esac
1853
1854 config_shell=${CONFIG_SHELL-/bin/sh}
1855
1856 moveifchange=${srcdir}/move-if-change
1857
1858 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1859
1860 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1861 # a relative path.
1862 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1863   INSTALL="${srcpwd}/install-sh -c"
1864 fi
1865
1866 # Set srcdir to "." if that's what it is.
1867 # This is important for multilib support.
1868 pwd=`${PWDCMD-pwd}`
1869 if test "${pwd}" = "${srcpwd}" ; then
1870   srcdir=.
1871 fi
1872
1873 topsrcdir=$srcpwd
1874
1875 extra_host_args=
1876
1877 ### To add a new directory to the tree, first choose whether it is a target
1878 ### or a host dependent tool.  Then put it into the appropriate list
1879 ### (library or tools, host or target), doing a dependency sort.
1880
1881 # Subdirs will be configured in the order listed in build_configdirs,
1882 # configdirs, or target_configdirs; see the serialization section below.
1883
1884 # Dependency sorting is only needed when *configuration* must be done in
1885 # a particular order.  In all cases a dependency should be specified in
1886 # the Makefile, whether or not it's implicitly specified here.
1887
1888 # Double entries in build_configdirs, configdirs, or target_configdirs may
1889 # cause circular dependencies and break everything horribly.
1890
1891 # these library is used by various programs built for the build
1892 # environment
1893 #
1894 build_libs="build-libiberty"
1895
1896 # these tools are built for the build environment
1897 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1898
1899 # these libraries are used by various programs built for the host environment
1900 #
1901 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1902
1903 # these tools are built for the host environment
1904 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1905 # know that we are building the simulator.
1906 # binutils, gas and ld appear in that order because it makes sense to run
1907 # "make check" in that particular order.
1908 # If --enable-gold is used, "gold" will replace "ld".
1909 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc cgen sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1910
1911 # libgcj represents the runtime libraries only used by gcj.
1912 libgcj="target-libffi \
1913         target-zlib \
1914         target-qthreads \
1915         target-libjava"
1916
1917 # these libraries are built for the target environment, and are built after
1918 # the host libraries and the host tools (which may be a cross compiler)
1919 #
1920 target_libraries="target-libgcc \
1921                 target-libiberty \
1922                 target-libgloss \
1923                 target-newlib \
1924                 target-libgomp \
1925                 target-libstdc++-v3 \
1926                 target-libmudflap \
1927                 target-libssp \
1928                 target-libgfortran \
1929                 target-boehm-gc \
1930                 ${libgcj} \
1931                 target-libobjc \
1932                 target-libada"
1933
1934 # these tools are built using the target libraries, and are intended to
1935 # run only in the target environment
1936 #
1937 # note: any program that *uses* libraries that are in the "target_libraries"
1938 # list belongs in this list.  those programs are also very likely
1939 # candidates for the "native_only" list which follows
1940 #
1941 target_tools="target-examples target-groff target-gperf target-rda"
1942
1943 ################################################################################
1944
1945 ## All tools belong in one of the four categories, and are assigned above
1946 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1947 ## is important because configure will choke if they ever get through.
1948 ## ${configdirs} is directories we build using the host tools.
1949 ## ${target_configdirs} is directories we build using the target tools.
1950 configdirs=`echo ${host_libs} ${host_tools}`
1951 target_configdirs=`echo ${target_libraries} ${target_tools}`
1952 build_configdirs=`echo ${build_libs} ${build_tools}`
1953
1954
1955
1956 ################################################################################
1957
1958 srcname="gnu development package"
1959
1960 # This gets set non-empty for some net releases of packages.
1961 appdirs=""
1962
1963 # Define is_cross_compiler to save on calls to 'test'.
1964 is_cross_compiler=
1965 if test x"${host}" = x"${target}" ; then
1966   is_cross_compiler=no
1967 else
1968   is_cross_compiler=yes
1969 fi
1970
1971 # Find the build and target subdir names.
1972
1973 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1974 # have matching libraries, they should use host libraries: Makefile.tpl
1975 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1976 # However, they still use the build modules, because the corresponding
1977 # host modules (e.g. bison) are only built for the host when bootstrap
1978 # finishes. So:
1979 # - build_subdir is where we find build modules, and never changes.
1980 # - build_libsubdir is where we find build libraries, and can be overridden.
1981
1982 # Prefix 'build-' so this never conflicts with target_subdir.
1983 build_subdir="build-${build_noncanonical}"
1984
1985 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1986 if test "${with_build_libsubdir+set}" = set; then
1987   withval="$with_build_libsubdir"
1988   build_libsubdir="$withval"
1989 else
1990   build_libsubdir="$build_subdir"
1991 fi;
1992 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1993 if ( test $srcdir = . && test -d gcc ) \
1994    || test -d $srcdir/../host-${host_noncanonical}; then
1995   host_subdir="host-${host_noncanonical}"
1996 else
1997   host_subdir=.
1998 fi
1999 # No prefix.
2000 target_subdir=${target_noncanonical}
2001
2002
2003 # Skipdirs are removed silently.
2004 skipdirs=
2005 # Noconfigdirs are removed loudly.
2006 noconfigdirs=""
2007
2008 use_gnu_ld=
2009 # Make sure we don't let GNU ld be added if we didn't want it.
2010 if test x$with_gnu_ld = xno ; then
2011   use_gnu_ld=no
2012   noconfigdirs="$noconfigdirs ld gold"
2013 fi
2014
2015 use_gnu_as=
2016 # Make sure we don't let GNU as be added if we didn't want it.
2017 if test x$with_gnu_as = xno ; then
2018   use_gnu_as=no
2019   noconfigdirs="$noconfigdirs gas"
2020 fi
2021
2022 # some tools are so dependent upon X11 that if we're not building with X,
2023 # it's not even worth trying to configure, much less build, that tool.
2024
2025 case ${with_x} in
2026   yes | "") ;; # the default value for this tree is that X11 is available
2027   no)
2028     skipdirs="${skipdirs} tk itcl libgui"
2029     # We won't be able to build gdbtk without X.
2030     enable_gdbtk=no
2031     ;;
2032   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2033 esac
2034
2035 # Some tools are only suitable for building in a "native" situation.
2036 # Remove these if host!=target.
2037 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2038
2039 # Similarly, some are only suitable for cross toolchains.
2040 # Remove these if host=target.
2041 cross_only="target-libgloss target-newlib target-opcodes"
2042
2043 case $is_cross_compiler in
2044   no) skipdirs="${skipdirs} ${cross_only}" ;;
2045   yes) skipdirs="${skipdirs} ${native_only}" ;;
2046 esac
2047
2048 # If both --with-headers and --with-libs are specified, default to
2049 # --without-newlib.
2050 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2051    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2052   if test x"${with_newlib}" = x ; then
2053     with_newlib=no
2054   fi
2055 fi
2056
2057 # Recognize --with-newlib/--without-newlib.
2058 case ${with_newlib} in
2059   no) skipdirs="${skipdirs} target-newlib" ;;
2060   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2061 esac
2062
2063 # Handle --enable-gold.
2064
2065 # Check whether --enable-gold or --disable-gold was given.
2066 if test "${enable_gold+set}" = set; then
2067   enableval="$enable_gold"
2068   ENABLE_GOLD=$enableval
2069 else
2070   ENABLE_GOLD=no
2071 fi;
2072 if test "${ENABLE_GOLD}" = "yes"; then
2073   # Check for ELF target.
2074   is_elf=no
2075   case "${target}" in
2076     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2077     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2078     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2079       case "${target}" in
2080         *-*-linux*aout* | *-*-linux*oldld*)
2081           ;;
2082         *)
2083           is_elf=yes
2084           ;;
2085       esac
2086   esac
2087
2088   if test "$is_elf" = "yes"; then
2089     # Check for target supported by gold.
2090     case "${target}" in
2091       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2092         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2093         ;;
2094     esac
2095   fi
2096 fi
2097
2098 # Configure extra directories which are host specific
2099
2100 case "${host}" in
2101   *-cygwin*)
2102     configdirs="$configdirs libtermcap" ;;
2103 esac
2104
2105 # A target can indicate whether a language isn't supported for some reason.
2106 # Only spaces may be used in this macro; not newlines or tabs.
2107 unsupported_languages=
2108
2109 # Remove more programs from consideration, based on the host or
2110 # target this usually means that a port of the program doesn't
2111 # exist yet.
2112
2113 case "${host}" in
2114   hppa*64*-*-*)
2115     noconfigdirs="$noconfigdirs byacc"
2116     ;;
2117   i[3456789]86-*-vsta)
2118     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2119     ;;
2120   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2121     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2122     ;;
2123   x86_64-*-mingw*)
2124     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2125     ;;
2126   i[3456789]86-*-mingw32*)
2127     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2128     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2129     ;;
2130   i[3456789]86-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2132     ;;
2133   *-*-cygwin*)
2134     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2135     ;;
2136   *-*-netbsd*)
2137     noconfigdirs="$noconfigdirs rcs"
2138     ;;
2139   ppc*-*-pe)
2140     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2141     ;;
2142   powerpc-*-beos*)
2143     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2144     ;;
2145 esac
2146
2147
2148 # Check whether --enable-libada or --disable-libada was given.
2149 if test "${enable_libada+set}" = set; then
2150   enableval="$enable_libada"
2151   ENABLE_LIBADA=$enableval
2152 else
2153   ENABLE_LIBADA=yes
2154 fi;
2155 if test "${ENABLE_LIBADA}" != "yes" ; then
2156   noconfigdirs="$noconfigdirs gnattools"
2157 fi
2158
2159 # Check whether --enable-libssp or --disable-libssp was given.
2160 if test "${enable_libssp+set}" = set; then
2161   enableval="$enable_libssp"
2162   ENABLE_LIBSSP=$enableval
2163 else
2164   ENABLE_LIBSSP=yes
2165 fi;
2166
2167 # Save it here so that, even in case of --enable-libgcj, if the Java
2168 # front-end isn't enabled, we still get libgcj disabled.
2169 libgcj_saved=$libgcj
2170 case $enable_libgcj in
2171 yes)
2172   # If we reset it here, it won't get added to noconfigdirs in the
2173   # target-specific build rules, so it will be forcibly enabled
2174   # (unless the Java language itself isn't enabled).
2175   libgcj=
2176   ;;
2177 no)
2178   # Make sure we get it printed in the list of not supported target libs.
2179   noconfigdirs="$noconfigdirs ${libgcj}"
2180   ;;
2181 esac
2182
2183
2184 # Disable libmudflap on some systems.
2185 if test x$enable_libmudflap = x ; then
2186     case "${target}" in
2187     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2188         # Enable libmudflap by default in GNU and friends.
2189         ;;
2190     *-*-freebsd*)
2191         # Enable libmudflap by default in FreeBSD.
2192         ;;
2193     *)
2194         # Disable it by default everywhere else.
2195         noconfigdirs="$noconfigdirs target-libmudflap"
2196         ;;
2197     esac
2198 fi
2199
2200 # Disable libgomp on non POSIX hosted systems.
2201 if test x$enable_libgomp = x ; then
2202     # Enable libgomp by default on hosted POSIX systems.
2203     case "${target}" in
2204     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2205         ;;
2206     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2207         ;;
2208     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2209         ;;
2210     *-*-darwin* | *-*-aix*)
2211         ;;
2212     *)
2213         noconfigdirs="$noconfigdirs target-libgomp"
2214         ;;
2215     esac
2216 fi
2217
2218 # Default libgloss CPU subdirectory.
2219 libgloss_dir="$target_cpu"
2220
2221 case "${target}" in
2222   *-*-chorusos)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   powerpc-*-darwin*)
2226     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2227     noconfigdirs="$noconfigdirs sim target-rda"
2228     ;;
2229   i[3456789]86-*-darwin*)
2230     noconfigdirs="$noconfigdirs ld gprof"
2231     noconfigdirs="$noconfigdirs sim target-rda"
2232     ;;
2233   x86_64-*-darwin[912]*)
2234     noconfigdirs="$noconfigdirs ld gas gprof"
2235     noconfigdirs="$noconfigdirs sim target-rda"
2236     ;;
2237   *-*-darwin*)
2238     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2239     noconfigdirs="$noconfigdirs sim target-rda"
2240     noconfigdirs="$noconfigdirs ${libgcj}"
2241     ;;
2242   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2243     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2244     ;;
2245   *-*-freebsd*)
2246     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2247     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2248         && test -f /usr/local/include/gmp.h; then
2249       with_gmp=/usr/local
2250     fi
2251
2252     # Skip some stuff that's unsupported on some FreeBSD configurations.
2253     case "${target}" in
2254       i*86-*-*) ;;
2255       alpha*-*-*) ;;
2256       *)
2257         noconfigdirs="$noconfigdirs ${libgcj}"
2258         ;;
2259     esac
2260     ;;
2261   *-*-kaos*)
2262     # Remove unsupported stuff on all kaOS configurations.
2263     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2264     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2265     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2266     noconfigdirs="$noconfigdirs target-libgloss"
2267     ;;
2268   *-*-netbsd*)
2269     # Skip some stuff on all NetBSD configurations.
2270     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2271
2272     # Skip some stuff that's unsupported on some NetBSD configurations.
2273     case "${target}" in
2274       i*86-*-netbsdelf*) ;;
2275       arm*-*-netbsdelf*) ;;
2276       *)
2277         noconfigdirs="$noconfigdirs ${libgcj}"
2278         ;;
2279     esac
2280     ;;
2281   *-*-netware*)
2282     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2283     ;;
2284   *-*-rtems*)
2285     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2286     ;;
2287     # The tpf target doesn't support gdb yet.
2288   *-*-tpf*)
2289     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2290     ;;
2291   *-*-uclinux*)
2292     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2293     ;;
2294   *-*-vxworks*)
2295     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2296     ;;
2297   alpha*-dec-osf*)
2298     # ld works, but does not support shared libraries.
2299     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2300     # gas doesn't generate exception information.
2301     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2302     ;;
2303   alpha*-*-*vms*)
2304     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2305     ;;
2306   alpha*-*-linux*)
2307     # newlib is not 64 bit ready
2308     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2309     ;;
2310   alpha*-*-*)
2311     # newlib is not 64 bit ready
2312     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2313     ;;
2314   am33_2.0-*-linux*)
2315     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2316     ;;
2317   sh-*-linux*)
2318     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2319     ;;
2320   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2321     noconfigdirs="$noconfigdirs ${libgcj}"
2322     noconfigdirs="$noconfigdirs target-examples"
2323     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2324     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2325     noconfigdirs="$noconfigdirs expect dejagnu"
2326     # the C++ libraries don't build on top of CE's C libraries
2327     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2328     noconfigdirs="$noconfigdirs target-newlib"
2329     case "${host}" in
2330       *-*-cygwin*) ;; # keep gdb and readline
2331       *) noconfigdirs="$noconfigdirs gdb readline"
2332          ;;
2333     esac
2334     libgloss_dir=wince
2335     ;;
2336   arc-*-*)
2337     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2338     ;;
2339   arm-semi-aof )
2340     ;;
2341   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2342     noconfigdirs="$noconfigdirs ${libgcj}"
2343     libgloss_dir=arm
2344     ;;
2345   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2346     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2347     libgloss_dir=arm
2348     ;;
2349   arm*-*-linux-gnueabi)
2350     noconfigdirs="$noconfigdirs target-qthreads"
2351     case ${with_newlib} in
2352       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2353     esac
2354     libgloss_dir=arm
2355     ;;
2356   arm*-*-symbianelf*)
2357     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2358     libgloss_dir=arm
2359     ;;
2360   arm-*-pe*)
2361     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2362     ;;
2363   thumb-*-coff)
2364     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2365     ;;
2366   thumb-*-elf)
2367     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2368     ;;
2369   thumb-*-pe)
2370     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2371     ;;
2372   arm-*-riscix*)
2373     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2374     ;;
2375   avr-*-*)
2376     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2377     ;;
2378   bfin-*-*)
2379     noconfigdirs="$noconfigdirs gdb"
2380     if test x${is_cross_compiler} != xno ; then
2381       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2382     fi
2383     ;;
2384   c4x-*-* | tic4x-*-*)
2385     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2386     ;;
2387   c54x*-*-* | tic54x-*-*)
2388     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2389     ;;
2390   cr16-*-*)
2391     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2392     ;;
2393   cris-*-* | crisv32-*-*)
2394     unsupported_languages="$unsupported_languages java"
2395     case "${target}" in
2396       *-*-aout)
2397         unsupported_languages="$unsupported_languages fortran"
2398         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2399       *-*-elf)
2400         noconfigdirs="$noconfigdirs target-boehm-gc";;
2401       *-*-linux*)
2402         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2403       *)
2404         unsupported_languages="$unsupported_languages fortran"
2405         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2406     esac
2407     libgloss_dir=cris
2408     ;;
2409   crx-*-*)
2410     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2411     ;;
2412   d10v-*-*)
2413     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2414     ;;
2415   d30v-*-*)
2416     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2417     ;;
2418   ep9312-*-elf | ep9312-*-coff)
2419     libgloss_dir=arm
2420     ;;
2421   fr30-*-elf*)
2422     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2423     ;;
2424   frv-*-*)
2425     noconfigdirs="$noconfigdirs ${libgcj}"
2426     ;;
2427   moxie-*-*)
2428     noconfigdirs="$noconfigdirs ${libgcj}"
2429     noconfigdirs="$noconfigdirs gprof"
2430     ;;
2431   h8300*-*-*)
2432     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2433     ;;
2434   h8500-*-*)
2435     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2436     ;;
2437   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2438     ;;
2439   hppa*64*-*-linux* | parisc*64*-*-linux*)
2440     # In this case, it's because the hppa64-linux target is for
2441     # the kernel only at this point and has no libc, and thus no
2442     # headers, crt*.o, etc., all of which are needed by these.
2443     noconfigdirs="$noconfigdirs target-zlib"
2444     ;;
2445   parisc*-*-linux* | hppa*-*-linux*)
2446     ;;
2447   hppa*-*-*elf* | \
2448   hppa*-*-lites* | \
2449   hppa*-*-openbsd* | \
2450   hppa*64*-*-*)
2451     noconfigdirs="$noconfigdirs ${libgcj}"
2452     ;;
2453   hppa*-hp-hpux11*)
2454     noconfigdirs="$noconfigdirs ld shellutils"
2455     ;;
2456   hppa*-*-pro*)
2457     libgloss_dir=pa
2458     ;;
2459   hppa*-*-*)
2460     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2461     # build on HP-UX 10.20.
2462     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2463     ;;
2464   i960-*-*)
2465     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2466     ;;
2467   ia64*-*-elf*)
2468     # No gdb support yet.
2469     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2470     ;;
2471   ia64*-**-hpux*)
2472     # No gdb or ld support yet.
2473     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2474     ;;
2475   ia64*-*-*vms*)
2476     # No gdb or ld support yet.
2477     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2478     ;;
2479   i370-*-opened*)
2480     ;;
2481   i[3456789]86-*-coff | i[3456789]86-*-elf)
2482     noconfigdirs="$noconfigdirs ${libgcj}"
2483     libgloss_dir=i386
2484     ;;
2485   i[3456789]86-*-linux*)
2486     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2487     # not build java stuff by default.
2488     case "${target}" in
2489       *-*-*libc1*)
2490         noconfigdirs="$noconfigdirs ${libgcj}";;
2491     esac
2492
2493     # This section makes it possible to build newlib natively on linux.
2494     # If we are using a cross compiler then don't configure newlib.
2495     if test x${is_cross_compiler} != xno ; then
2496       noconfigdirs="$noconfigdirs target-newlib"
2497     fi
2498     noconfigdirs="$noconfigdirs target-libgloss"
2499     # If we are not using a cross compiler, do configure newlib.
2500     # Note however, that newlib will only be configured in this situation
2501     # if the --with-newlib option has been given, because otherwise
2502     # 'target-newlib' will appear in skipdirs.
2503     ;;
2504   i[3456789]86-*-mingw32*)
2505     target_configdirs="$target_configdirs target-winsup"
2506     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2507     ;;
2508   x86_64-*-mingw*)
2509     target_configdirs="$target_configdirs target-winsup"
2510     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2511     ;;
2512   *-*-cygwin*)
2513     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2514     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2515     # always build newlib if winsup directory is present.
2516     if test -d "$srcdir/winsup/cygwin"; then
2517       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2518     elif test -d "$srcdir/newlib"; then
2519       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2520     fi
2521     ;;
2522   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2523   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2524     ;;
2525   i[3456789]86-*-pe)
2526     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2527     ;;
2528   i[3456789]86-*-sco3.2v5*)
2529     # The linker does not yet know about weak symbols in COFF,
2530     # and is not configured to handle mixed ELF and COFF.
2531     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2532     ;;
2533   i[3456789]86-*-sco*)
2534     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2535     ;;
2536   i[3456789]86-*-solaris2*)
2537     noconfigdirs="$noconfigdirs target-libgloss"
2538     ;;
2539   i[3456789]86-*-sysv4*)
2540     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2541     ;;
2542   i[3456789]86-*-beos*)
2543     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2544     ;;
2545   i[3456789]86-*-rdos*)
2546     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2547     ;;
2548   m32r-*-*)
2549     noconfigdirs="$noconfigdirs ${libgcj}"
2550     ;;
2551   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2552     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2553     libgloss_dir=m68hc11
2554     ;;
2555   m68k-*-elf*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     ;;
2558   m68k-*-coff*)
2559     noconfigdirs="$noconfigdirs ${libgcj}"
2560     ;;
2561   m68*-*-* | fido-*-*)
2562     libgloss_dir=m68k
2563     ;;
2564   mcore-*-pe*)
2565   # The EPOC C++ environment does not support exceptions or rtti,
2566   # and so building libstdc++-v3 tends not to always work.
2567     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2568     ;;
2569   mmix-*-*)
2570     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2571     unsupported_languages="$unsupported_languages fortran java"
2572     ;;
2573   mn10200-*-*)
2574     noconfigdirs="$noconfigdirs ${libgcj}"
2575     ;;
2576   mn10300-*-*)
2577     noconfigdirs="$noconfigdirs ${libgcj}"
2578     ;;
2579   mt-*-*)
2580     noconfigdirs="$noconfigdirs sim"
2581     ;;
2582   powerpc-*-aix*)
2583     # copied from rs6000-*-* entry
2584     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2585     ;;
2586   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2587     target_configdirs="$target_configdirs target-winsup"
2588     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2589     # always build newlib.
2590     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2591     ;;
2592     # This is temporary until we can link against shared libraries
2593   powerpcle-*-solaris*)
2594     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2595     libgloss_dir=rs6000
2596     ;;
2597   powerpc-*-beos*)
2598     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2599     ;;
2600   powerpc-*-eabi)
2601     noconfigdirs="$noconfigdirs ${libgcj}"
2602     libgloss_dir=rs6000
2603     ;;
2604   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2605     libgloss_dir=rs6000
2606     ;;
2607   rs6000-*-lynxos*)
2608     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2609     ;;
2610   rs6000-*-aix*)
2611     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2612     ;;
2613   rs6000-*-*)
2614     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2615     ;;
2616   m68k-apollo-*)
2617     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2618     ;;
2619   microblaze*)
2620     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2621     ;;
2622   mips*-sde-elf*)
2623     skipdirs="$skipdirs target-libiberty"
2624     noconfigdirs="$noconfigdirs ${libgcj}"
2625     if test x$with_newlib = xyes; then
2626       noconfigdirs="$noconfigdirs gprof"
2627     fi
2628     libgloss_dir=mips
2629     ;;
2630   mips*-*-irix5*)
2631     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2632     ;;
2633   mips*-*-irix6*)
2634     # Linking libjava exceeds command-line length limits on at least
2635     # IRIX 6.2, but not on IRIX 6.5.
2636     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2637     # <oldham@codesourcery.com>
2638     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2639     ;;
2640   mips*-*-bsd*)
2641     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2642     ;;
2643   mips*-*-linux*)
2644     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2645     ;;
2646   mips*-*-*)
2647     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2648     libgloss_dir=mips
2649     ;;
2650   romp-*-*)
2651     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2652     ;;
2653   sh-*-* | sh64-*-*)
2654     case "${host}" in
2655       i[3456789]86-*-vsta) ;; # don't add gprof back in
2656       i[3456789]86-*-go32*) ;; # don't add gprof back in
2657       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2658       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2659     esac
2660     case "${target}" in
2661       sh*-*-elf)
2662          noconfigdirs="$noconfigdirs ${libgcj}" ;;
2663       *)
2664          noconfigdirs="$noconfigdirs target-libgloss ${libgcj}" ;;
2665     esac
2666     ;;
2667   sparclet-*-aout* | sparc86x-*-*)
2668     libgloss_dir=sparc
2669     ;;
2670   sparc-*-elf*)
2671     noconfigdirs="$noconfigdirs ${libgcj}"
2672     ;;
2673   sparc64-*-elf*)
2674     noconfigdirs="$noconfigdirs ${libgcj}"
2675     libgloss_dir=sparc
2676     ;;
2677   sparclite-*-*)
2678     noconfigdirs="$noconfigdirs ${libgcj}"
2679     libgloss_dir=sparc
2680     ;;
2681   sparc-*-sunos4*)
2682     noconfigdirs="$noconfigdirs ${libgcj}"
2683     if test x${is_cross_compiler} != xno ; then
2684            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2685     else
2686            use_gnu_ld=no
2687     fi
2688     ;;
2689   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2690     noconfigdirs="$noconfigdirs ${libgcj}"
2691     ;;
2692   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2693     ;;
2694   v810-*-*)
2695     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2696     ;;
2697   v850-*-*)
2698     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2699     ;;
2700   v850e-*-*)
2701     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2702     ;;
2703   v850ea-*-*)
2704     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2705     ;;
2706   vax-*-vms)
2707     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2708     ;;
2709   vax-*-*)
2710     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2711     ;;
2712   xtensa*-*-*)
2713     noconfigdirs="$noconfigdirs ${libgcj}"
2714     ;;
2715   ip2k-*-*)
2716     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2717     ;;
2718   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2719     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2720     ;;
2721   *-*-lynxos*)
2722     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2723     ;;
2724   *-*-*)
2725     noconfigdirs="$noconfigdirs ${libgcj}"
2726     ;;
2727 esac
2728
2729 # If we aren't building newlib, then don't build libgloss, since libgloss
2730 # depends upon some newlib header files.
2731 case "${noconfigdirs}" in
2732   *target-libgloss*) ;;
2733   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2734 esac
2735
2736 # Work in distributions that contain no compiler tools, like Autoconf.
2737 tentative_cc=""
2738 host_makefile_frag=/dev/null
2739 if test -d ${srcdir}/config ; then
2740 case "${host}" in
2741   m68k-hp-hpux*)
2742     # Avoid "too much defining" errors from HPUX compiler.
2743     tentative_cc="cc -Wp,-H256000"
2744     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2745     # If it's HP/UX ar, this should be harmless.
2746     RANLIB="ar ts"
2747     ;;
2748   m68k-apollo-sysv*)
2749     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2750     ;;
2751   m68k-apollo-bsd*)
2752     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2753     # chokes on bfd, the compiler won't let you assign integers to enums, and
2754     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2755     # the apollo compiler" (the preferred version of GCC could be called cc,
2756     # or whatever), but I'm not sure leaving CC as cc is any better...
2757     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2758     # Used to have BISON=yacc.
2759     tentative_cc=gcc
2760     ;;
2761   m88k-dg-dgux*)
2762     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2763     ;;
2764   m88k-harris-cxux*)
2765     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2766     tentative_cc="cc -Xa"
2767     host_makefile_frag="config/mh-cxux"
2768     ;;
2769   m88k-motorola-sysv*)
2770     ;;
2771   mips*-dec-ultrix*)
2772     tentative_cc="cc -Wf,-XNg1000"
2773     host_makefile_frag="config/mh-decstation"
2774     ;;
2775   mips*-nec-sysv4*)
2776     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2777     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2778     host_makefile_frag="config/mh-necv4"
2779     ;;
2780   mips*-sgi-irix4*)
2781     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2782     # environment.  Also bump switch table size so that cp-parse will
2783     # compile.  Bump string length limit so linker builds.
2784     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2785     ;;
2786   mips*-*-sysv4*)
2787     host_makefile_frag="config/mh-sysv4"
2788     ;;
2789   mips*-*-sysv*)
2790     # This is for a MIPS running RISC/os 4.52C.
2791
2792     # This is needed for GDB, but needs to be in the top-level make because
2793     # if a library is compiled with the bsd headers and gets linked with the
2794     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2795     # a different size).
2796     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2797     # known except to select the sysv environment.  Could we use /proc instead?
2798     # These "sysv environments" and "bsd environments" often end up being a pain.
2799     #
2800     # This is not part of CFLAGS because perhaps not all C compilers have this
2801     # option.
2802     tentative_cc="cc -systype sysv"
2803     ;;
2804   i370-ibm-opened*)
2805     tentative_cc="c89"
2806     ;;
2807   i[3456789]86-*-sysv5*)
2808     host_makefile_frag="config/mh-sysv5"
2809     ;;
2810   i[3456789]86-*-dgux*)
2811     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2812     host_makefile_frag="config/mh-dgux386"
2813     ;;
2814   i[3456789]86-ncr-sysv4.3*)
2815     # The MetaWare compiler will generate a copyright message unless you
2816     # turn it off by adding the -Hnocopyr flag.
2817     tentative_cc="cc -Hnocopyr"
2818     ;;
2819   i[3456789]86-ncr-sysv4*)
2820     # for an NCR 3000 (i486/SVR4) system.
2821     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2822     # This compiler not only emits obnoxious copyright messages every time
2823     # you run it, but it chokes and dies on a whole bunch of GNU source
2824     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2825     tentative_cc="/usr/ccs/ATT/cc"
2826     host_makefile_frag="config/mh-ncr3000"
2827     ;;
2828   i[3456789]86-*-sco3.2v5*)
2829     ;;
2830   i[3456789]86-*-sco*)
2831     # The native C compiler botches some simple uses of const.  Unfortunately,
2832     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2833     tentative_cc="cc -Dconst="
2834     host_makefile_frag="config/mh-sco"
2835     ;;
2836   i[3456789]86-*-udk*)
2837     host_makefile_frag="config/mh-sysv5"
2838     ;;
2839   i[3456789]86-*-solaris2*)
2840     host_makefile_frag="config/mh-sysv4"
2841     ;;
2842   i[3456789]86-*-msdosdjgpp*)
2843     host_makefile_frag="config/mh-djgpp"
2844     ;;
2845   *-cygwin*)
2846
2847 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2848 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2849 echo a >cygwin-cat-check
2850 if test `cat cygwin-cat-check` == a ; then
2851   rm cygwin-cat-check
2852   echo "$as_me:$LINENO: result: yes" >&5
2853 echo "${ECHO_T}yes" >&6
2854 else
2855   rm cygwin-cat-check
2856   echo "$as_me:$LINENO: result: no" >&5
2857 echo "${ECHO_T}no" >&6
2858   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2859   Please either mount the build directory in binary mode or run the following
2860   commands before running any configure script:
2861 set -o igncr
2862 export SHELLOPTS
2863   " >&5
2864 echo "$as_me: error: The cat command does not ignore carriage return characters.
2865   Please either mount the build directory in binary mode or run the following
2866   commands before running any configure script:
2867 set -o igncr
2868 export SHELLOPTS
2869   " >&2;}
2870    { (exit 1); exit 1; }; }
2871 fi
2872
2873     host_makefile_frag="config/mh-cygwin"
2874     ;;
2875   *-mingw*)
2876     host_makefile_frag="config/mh-mingw"
2877     ;;
2878   *-interix*)
2879     host_makefile_frag="config/mh-interix"
2880     ;;
2881   vax-*-ultrix2*)
2882     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2883     tentative_cc=gcc
2884     ;;
2885   *-*-solaris2*)
2886     host_makefile_frag="config/mh-solaris"
2887     ;;
2888   m68k-sun-sunos*)
2889     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2890     # without overflowing the jump tables (-J says to use a 32 bit table)
2891     tentative_cc="cc -J"
2892     ;;
2893   hppa*-hp-hpux10*)
2894     tentative_cc="cc -Wp,-H256000"
2895     host_makefile_frag="config/mh-pa-hpux10"
2896     ;;
2897   hppa*-hp-hpux* | hppa*-*-hiux*)
2898     tentative_cc="cc -Wp,-H256000"
2899     host_makefile_frag="config/mh-pa"
2900     ;;
2901   hppa*-*)
2902     host_makefile_frag="config/mh-pa"
2903     ;;
2904   *-hp-hpux* | *-*-hiux*)
2905     tentative_cc="cc -Wp,-H256000"
2906     ;;
2907   rs6000-*-lynxos*)
2908     # /bin/cc is less than useful for our purposes.  Always use GCC
2909     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2910     host_makefile_frag="config/mh-lynxrs6k"
2911     ;;
2912   powerpc-*-darwin*)
2913     host_makefile_frag="config/mh-ppc-darwin"
2914     ;;
2915   powerpc-*-aix*)
2916     host_makefile_frag="config/mh-ppc-aix"
2917     ;;
2918   rs6000-*-aix*)
2919     host_makefile_frag="config/mh-ppc-aix"
2920     ;;
2921   *-*-lynxos*)
2922     # /bin/cc is less than useful for our purposes.  Always use GCC
2923     tentative_cc="/bin/gcc"
2924     ;;
2925   *-*-sysv4*)
2926     host_makefile_frag="config/mh-sysv4"
2927     ;;
2928   # This is placed last to prevent interfering with the cases above.
2929   i[3456789]86-*-*)
2930     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2931     host_makefile_frag="config/mh-x86omitfp"
2932     ;;
2933 esac
2934 fi
2935
2936 # If we aren't going to be using gcc, see if we can extract a definition
2937 # of CC from the fragment.
2938 # Actually, use the 'pre-extracted' version above.
2939 if test -z "${CC}" && test "${build}" = "${host}" ; then
2940   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2941   found=
2942   for dir in $PATH; do
2943     test -z "$dir" && dir=.
2944     if test -f $dir/gcc; then
2945       found=yes
2946       break
2947     fi
2948   done
2949   IFS="$save_ifs"
2950   if test -z "${found}" && test -n "${tentative_cc}" ; then
2951     CC=$tentative_cc
2952   fi
2953 fi
2954
2955 if test "${build}" != "${host}" ; then
2956   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2957   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2958   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2959   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2960   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2961   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2962   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2963   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2964   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2965   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2966   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2967   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2968 else
2969   AR_FOR_BUILD="\$(AR)"
2970   AS_FOR_BUILD="\$(AS)"
2971   CC_FOR_BUILD="\$(CC)"
2972   CXX_FOR_BUILD="\$(CXX)"
2973   GCJ_FOR_BUILD="\$(GCJ)"
2974   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2975   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2976   LD_FOR_BUILD="\$(LD)"
2977   NM_FOR_BUILD="\$(NM)"
2978   RANLIB_FOR_BUILD="\$(RANLIB)"
2979   WINDRES_FOR_BUILD="\$(WINDRES)"
2980   WINDMC_FOR_BUILD="\$(WINDMC)"
2981 fi
2982
2983 ac_ext=c
2984 ac_cpp='$CPP $CPPFLAGS'
2985 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2986 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2987 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2988 if test -n "$ac_tool_prefix"; then
2989   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2990 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2991 echo "$as_me:$LINENO: checking for $ac_word" >&5
2992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2993 if test "${ac_cv_prog_CC+set}" = set; then
2994   echo $ECHO_N "(cached) $ECHO_C" >&6
2995 else
2996   if test -n "$CC"; then
2997   ac_cv_prog_CC="$CC" # Let the user override the test.
2998 else
2999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3000 for as_dir in $PATH
3001 do
3002   IFS=$as_save_IFS
3003   test -z "$as_dir" && as_dir=.
3004   for ac_exec_ext in '' $ac_executable_extensions; do
3005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3006     ac_cv_prog_CC="${ac_tool_prefix}gcc"
3007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3008     break 2
3009   fi
3010 done
3011 done
3012
3013 fi
3014 fi
3015 CC=$ac_cv_prog_CC
3016 if test -n "$CC"; then
3017   echo "$as_me:$LINENO: result: $CC" >&5
3018 echo "${ECHO_T}$CC" >&6
3019 else
3020   echo "$as_me:$LINENO: result: no" >&5
3021 echo "${ECHO_T}no" >&6
3022 fi
3023
3024 fi
3025 if test -z "$ac_cv_prog_CC"; then
3026   ac_ct_CC=$CC
3027   # Extract the first word of "gcc", so it can be a program name with args.
3028 set dummy gcc; ac_word=$2
3029 echo "$as_me:$LINENO: checking for $ac_word" >&5
3030 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3031 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3032   echo $ECHO_N "(cached) $ECHO_C" >&6
3033 else
3034   if test -n "$ac_ct_CC"; then
3035   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3036 else
3037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3038 for as_dir in $PATH
3039 do
3040   IFS=$as_save_IFS
3041   test -z "$as_dir" && as_dir=.
3042   for ac_exec_ext in '' $ac_executable_extensions; do
3043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3044     ac_cv_prog_ac_ct_CC="gcc"
3045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3046     break 2
3047   fi
3048 done
3049 done
3050
3051 fi
3052 fi
3053 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3054 if test -n "$ac_ct_CC"; then
3055   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3056 echo "${ECHO_T}$ac_ct_CC" >&6
3057 else
3058   echo "$as_me:$LINENO: result: no" >&5
3059 echo "${ECHO_T}no" >&6
3060 fi
3061
3062   CC=$ac_ct_CC
3063 else
3064   CC="$ac_cv_prog_CC"
3065 fi
3066
3067 if test -z "$CC"; then
3068   if test -n "$ac_tool_prefix"; then
3069   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3070 set dummy ${ac_tool_prefix}cc; ac_word=$2
3071 echo "$as_me:$LINENO: checking for $ac_word" >&5
3072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3073 if test "${ac_cv_prog_CC+set}" = set; then
3074   echo $ECHO_N "(cached) $ECHO_C" >&6
3075 else
3076   if test -n "$CC"; then
3077   ac_cv_prog_CC="$CC" # Let the user override the test.
3078 else
3079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3080 for as_dir in $PATH
3081 do
3082   IFS=$as_save_IFS
3083   test -z "$as_dir" && as_dir=.
3084   for ac_exec_ext in '' $ac_executable_extensions; do
3085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3086     ac_cv_prog_CC="${ac_tool_prefix}cc"
3087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3088     break 2
3089   fi
3090 done
3091 done
3092
3093 fi
3094 fi
3095 CC=$ac_cv_prog_CC
3096 if test -n "$CC"; then
3097   echo "$as_me:$LINENO: result: $CC" >&5
3098 echo "${ECHO_T}$CC" >&6
3099 else
3100   echo "$as_me:$LINENO: result: no" >&5
3101 echo "${ECHO_T}no" >&6
3102 fi
3103
3104 fi
3105 if test -z "$ac_cv_prog_CC"; then
3106   ac_ct_CC=$CC
3107   # Extract the first word of "cc", so it can be a program name with args.
3108 set dummy cc; ac_word=$2
3109 echo "$as_me:$LINENO: checking for $ac_word" >&5
3110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3111 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3112   echo $ECHO_N "(cached) $ECHO_C" >&6
3113 else
3114   if test -n "$ac_ct_CC"; then
3115   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3116 else
3117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3118 for as_dir in $PATH
3119 do
3120   IFS=$as_save_IFS
3121   test -z "$as_dir" && as_dir=.
3122   for ac_exec_ext in '' $ac_executable_extensions; do
3123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3124     ac_cv_prog_ac_ct_CC="cc"
3125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3126     break 2
3127   fi
3128 done
3129 done
3130
3131 fi
3132 fi
3133 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3134 if test -n "$ac_ct_CC"; then
3135   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3136 echo "${ECHO_T}$ac_ct_CC" >&6
3137 else
3138   echo "$as_me:$LINENO: result: no" >&5
3139 echo "${ECHO_T}no" >&6
3140 fi
3141
3142   CC=$ac_ct_CC
3143 else
3144   CC="$ac_cv_prog_CC"
3145 fi
3146
3147 fi
3148 if test -z "$CC"; then
3149   # Extract the first word of "cc", so it can be a program name with args.
3150 set dummy cc; ac_word=$2
3151 echo "$as_me:$LINENO: checking for $ac_word" >&5
3152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3153 if test "${ac_cv_prog_CC+set}" = set; then
3154   echo $ECHO_N "(cached) $ECHO_C" >&6
3155 else
3156   if test -n "$CC"; then
3157   ac_cv_prog_CC="$CC" # Let the user override the test.
3158 else
3159   ac_prog_rejected=no
3160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3161 for as_dir in $PATH
3162 do
3163   IFS=$as_save_IFS
3164   test -z "$as_dir" && as_dir=.
3165   for ac_exec_ext in '' $ac_executable_extensions; do
3166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3167     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3168        ac_prog_rejected=yes
3169        continue
3170      fi
3171     ac_cv_prog_CC="cc"
3172     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3173     break 2
3174   fi
3175 done
3176 done
3177
3178 if test $ac_prog_rejected = yes; then
3179   # We found a bogon in the path, so make sure we never use it.
3180   set dummy $ac_cv_prog_CC
3181   shift
3182   if test $# != 0; then
3183     # We chose a different compiler from the bogus one.
3184     # However, it has the same basename, so the bogon will be chosen
3185     # first if we set CC to just the basename; use the full file name.
3186     shift
3187     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3188   fi
3189 fi
3190 fi
3191 fi
3192 CC=$ac_cv_prog_CC
3193 if test -n "$CC"; then
3194   echo "$as_me:$LINENO: result: $CC" >&5
3195 echo "${ECHO_T}$CC" >&6
3196 else
3197   echo "$as_me:$LINENO: result: no" >&5
3198 echo "${ECHO_T}no" >&6
3199 fi
3200
3201 fi
3202 if test -z "$CC"; then
3203   if test -n "$ac_tool_prefix"; then
3204   for ac_prog in cl
3205   do
3206     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3207 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3208 echo "$as_me:$LINENO: checking for $ac_word" >&5
3209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3210 if test "${ac_cv_prog_CC+set}" = set; then
3211   echo $ECHO_N "(cached) $ECHO_C" >&6
3212 else
3213   if test -n "$CC"; then
3214   ac_cv_prog_CC="$CC" # Let the user override the test.
3215 else
3216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3217 for as_dir in $PATH
3218 do
3219   IFS=$as_save_IFS
3220   test -z "$as_dir" && as_dir=.
3221   for ac_exec_ext in '' $ac_executable_extensions; do
3222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3223     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3225     break 2
3226   fi
3227 done
3228 done
3229
3230 fi
3231 fi
3232 CC=$ac_cv_prog_CC
3233 if test -n "$CC"; then
3234   echo "$as_me:$LINENO: result: $CC" >&5
3235 echo "${ECHO_T}$CC" >&6
3236 else
3237   echo "$as_me:$LINENO: result: no" >&5
3238 echo "${ECHO_T}no" >&6
3239 fi
3240
3241     test -n "$CC" && break
3242   done
3243 fi
3244 if test -z "$CC"; then
3245   ac_ct_CC=$CC
3246   for ac_prog in cl
3247 do
3248   # Extract the first word of "$ac_prog", so it can be a program name with args.
3249 set dummy $ac_prog; ac_word=$2
3250 echo "$as_me:$LINENO: checking for $ac_word" >&5
3251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3252 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3253   echo $ECHO_N "(cached) $ECHO_C" >&6
3254 else
3255   if test -n "$ac_ct_CC"; then
3256   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3257 else
3258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3259 for as_dir in $PATH
3260 do
3261   IFS=$as_save_IFS
3262   test -z "$as_dir" && as_dir=.
3263   for ac_exec_ext in '' $ac_executable_extensions; do
3264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3265     ac_cv_prog_ac_ct_CC="$ac_prog"
3266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3267     break 2
3268   fi
3269 done
3270 done
3271
3272 fi
3273 fi
3274 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3275 if test -n "$ac_ct_CC"; then
3276   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3277 echo "${ECHO_T}$ac_ct_CC" >&6
3278 else
3279   echo "$as_me:$LINENO: result: no" >&5
3280 echo "${ECHO_T}no" >&6
3281 fi
3282
3283   test -n "$ac_ct_CC" && break
3284 done
3285
3286   CC=$ac_ct_CC
3287 fi
3288
3289 fi
3290
3291
3292 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3293 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3294 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3295 See \`config.log' for more details." >&5
3296 echo "$as_me: error: no acceptable C compiler found in \$PATH
3297 See \`config.log' for more details." >&2;}
3298    { (exit 1); exit 1; }; }; }
3299
3300 # Provide some information about the compiler.
3301 echo "$as_me:$LINENO:" \
3302      "checking for C compiler version" >&5
3303 ac_compiler=`set X $ac_compile; echo $2`
3304 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3305   (eval $ac_compiler --version </dev/null >&5) 2>&5
3306   ac_status=$?
3307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3308   (exit $ac_status); }
3309 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3310   (eval $ac_compiler -v </dev/null >&5) 2>&5
3311   ac_status=$?
3312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3313   (exit $ac_status); }
3314 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3315   (eval $ac_compiler -V </dev/null >&5) 2>&5
3316   ac_status=$?
3317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3318   (exit $ac_status); }
3319
3320 cat >conftest.$ac_ext <<_ACEOF
3321 /* confdefs.h.  */
3322 _ACEOF
3323 cat confdefs.h >>conftest.$ac_ext
3324 cat >>conftest.$ac_ext <<_ACEOF
3325 /* end confdefs.h.  */
3326
3327 int
3328 main ()
3329 {
3330
3331   ;
3332   return 0;
3333 }
3334 _ACEOF
3335 ac_clean_files_save=$ac_clean_files
3336 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3337 # Try to create an executable without -o first, disregard a.out.
3338 # It will help us diagnose broken compilers, and finding out an intuition
3339 # of exeext.
3340 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3341 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3342 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3343 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3344   (eval $ac_link_default) 2>&5
3345   ac_status=$?
3346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3347   (exit $ac_status); }; then
3348   # Find the output, starting from the most likely.  This scheme is
3349 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3350 # resort.
3351
3352 # Be careful to initialize this variable, since it used to be cached.
3353 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3354 ac_cv_exeext=
3355 # b.out is created by i960 compilers.
3356 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3357 do
3358   test -f "$ac_file" || continue
3359   case $ac_file in
3360     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3361         ;;
3362     conftest.$ac_ext )
3363         # This is the source file.
3364         ;;
3365     [ab].out )
3366         # We found the default executable, but exeext='' is most
3367         # certainly right.
3368         break;;
3369     *.* )
3370         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3371         # FIXME: I believe we export ac_cv_exeext for Libtool,
3372         # but it would be cool to find out if it's true.  Does anybody
3373         # maintain Libtool? --akim.
3374         export ac_cv_exeext
3375         break;;
3376     * )
3377         break;;
3378   esac
3379 done
3380 else
3381   echo "$as_me: failed program was:" >&5
3382 sed 's/^/| /' conftest.$ac_ext >&5
3383
3384 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3385 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3386 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3387 See \`config.log' for more details." >&5
3388 echo "$as_me: error: C compiler cannot create executables
3389 See \`config.log' for more details." >&2;}
3390    { (exit 77); exit 77; }; }; }
3391 fi
3392
3393 ac_exeext=$ac_cv_exeext
3394 echo "$as_me:$LINENO: result: $ac_file" >&5
3395 echo "${ECHO_T}$ac_file" >&6
3396
3397 # Check the compiler produces executables we can run.  If not, either
3398 # the compiler is broken, or we cross compile.
3399 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3400 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3401 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3402 # If not cross compiling, check that we can run a simple program.
3403 if test "$cross_compiling" != yes; then
3404   if { ac_try='./$ac_file'
3405   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3406   (eval $ac_try) 2>&5
3407   ac_status=$?
3408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3409   (exit $ac_status); }; }; then
3410     cross_compiling=no
3411   else
3412     if test "$cross_compiling" = maybe; then
3413         cross_compiling=yes
3414     else
3415         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3416 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3417 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3418 If you meant to cross compile, use \`--host'.
3419 See \`config.log' for more details." >&5
3420 echo "$as_me: error: cannot run C compiled programs.
3421 If you meant to cross compile, use \`--host'.
3422 See \`config.log' for more details." >&2;}
3423    { (exit 1); exit 1; }; }; }
3424     fi
3425   fi
3426 fi
3427 echo "$as_me:$LINENO: result: yes" >&5
3428 echo "${ECHO_T}yes" >&6
3429
3430 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3431 ac_clean_files=$ac_clean_files_save
3432 # Check the compiler produces executables we can run.  If not, either
3433 # the compiler is broken, or we cross compile.
3434 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3435 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3436 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3437 echo "${ECHO_T}$cross_compiling" >&6
3438
3439 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3440 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3441 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3442   (eval $ac_link) 2>&5
3443   ac_status=$?
3444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3445   (exit $ac_status); }; then
3446   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3447 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3448 # work properly (i.e., refer to `conftest.exe'), while it won't with
3449 # `rm'.
3450 for ac_file in conftest.exe conftest conftest.*; do
3451   test -f "$ac_file" || continue
3452   case $ac_file in
3453     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3454     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3455           export ac_cv_exeext
3456           break;;
3457     * ) break;;
3458   esac
3459 done
3460 else
3461   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3462 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3463 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3464 See \`config.log' for more details." >&5
3465 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3466 See \`config.log' for more details." >&2;}
3467    { (exit 1); exit 1; }; }; }
3468 fi
3469
3470 rm -f conftest$ac_cv_exeext
3471 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3472 echo "${ECHO_T}$ac_cv_exeext" >&6
3473
3474 rm -f conftest.$ac_ext
3475 EXEEXT=$ac_cv_exeext
3476 ac_exeext=$EXEEXT
3477 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3478 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3479 if test "${ac_cv_objext+set}" = set; then
3480   echo $ECHO_N "(cached) $ECHO_C" >&6
3481 else
3482   cat >conftest.$ac_ext <<_ACEOF
3483 /* confdefs.h.  */
3484 _ACEOF
3485 cat confdefs.h >>conftest.$ac_ext
3486 cat >>conftest.$ac_ext <<_ACEOF
3487 /* end confdefs.h.  */
3488
3489 int
3490 main ()
3491 {
3492
3493   ;
3494   return 0;
3495 }
3496 _ACEOF
3497 rm -f conftest.o conftest.obj
3498 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3499   (eval $ac_compile) 2>&5
3500   ac_status=$?
3501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3502   (exit $ac_status); }; then
3503   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3504   case $ac_file in
3505     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3506     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3507        break;;
3508   esac
3509 done
3510 else
3511   echo "$as_me: failed program was:" >&5
3512 sed 's/^/| /' conftest.$ac_ext >&5
3513
3514 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3515 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3516 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3517 See \`config.log' for more details." >&5
3518 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3519 See \`config.log' for more details." >&2;}
3520    { (exit 1); exit 1; }; }; }
3521 fi
3522
3523 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3524 fi
3525 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3526 echo "${ECHO_T}$ac_cv_objext" >&6
3527 OBJEXT=$ac_cv_objext
3528 ac_objext=$OBJEXT
3529 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3530 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3531 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3532   echo $ECHO_N "(cached) $ECHO_C" >&6
3533 else
3534   cat >conftest.$ac_ext <<_ACEOF
3535 /* confdefs.h.  */
3536 _ACEOF
3537 cat confdefs.h >>conftest.$ac_ext
3538 cat >>conftest.$ac_ext <<_ACEOF
3539 /* end confdefs.h.  */
3540
3541 int
3542 main ()
3543 {
3544 #ifndef __GNUC__
3545        choke me
3546 #endif
3547
3548   ;
3549   return 0;
3550 }
3551 _ACEOF
3552 rm -f conftest.$ac_objext
3553 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3554   (eval $ac_compile) 2>conftest.er1
3555   ac_status=$?
3556   grep -v '^ *+' conftest.er1 >conftest.err
3557   rm -f conftest.er1
3558   cat conftest.err >&5
3559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3560   (exit $ac_status); } &&
3561          { ac_try='test -z "$ac_c_werror_flag"
3562                          || test ! -s conftest.err'
3563   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3564   (eval $ac_try) 2>&5
3565   ac_status=$?
3566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3567   (exit $ac_status); }; } &&
3568          { ac_try='test -s conftest.$ac_objext'
3569   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3570   (eval $ac_try) 2>&5
3571   ac_status=$?
3572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3573   (exit $ac_status); }; }; then
3574   ac_compiler_gnu=yes
3575 else
3576   echo "$as_me: failed program was:" >&5
3577 sed 's/^/| /' conftest.$ac_ext >&5
3578
3579 ac_compiler_gnu=no
3580 fi
3581 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3582 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3583
3584 fi
3585 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3586 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3587 GCC=`test $ac_compiler_gnu = yes && echo yes`
3588 ac_test_CFLAGS=${CFLAGS+set}
3589 ac_save_CFLAGS=$CFLAGS
3590 CFLAGS="-g"
3591 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3592 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3593 if test "${ac_cv_prog_cc_g+set}" = set; then
3594   echo $ECHO_N "(cached) $ECHO_C" >&6
3595 else
3596   cat >conftest.$ac_ext <<_ACEOF
3597 /* confdefs.h.  */
3598 _ACEOF
3599 cat confdefs.h >>conftest.$ac_ext
3600 cat >>conftest.$ac_ext <<_ACEOF
3601 /* end confdefs.h.  */
3602
3603 int
3604 main ()
3605 {
3606
3607   ;
3608   return 0;
3609 }
3610 _ACEOF
3611 rm -f conftest.$ac_objext
3612 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3613   (eval $ac_compile) 2>conftest.er1
3614   ac_status=$?
3615   grep -v '^ *+' conftest.er1 >conftest.err
3616   rm -f conftest.er1
3617   cat conftest.err >&5
3618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3619   (exit $ac_status); } &&
3620          { ac_try='test -z "$ac_c_werror_flag"
3621                          || test ! -s conftest.err'
3622   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3623   (eval $ac_try) 2>&5
3624   ac_status=$?
3625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3626   (exit $ac_status); }; } &&
3627          { ac_try='test -s conftest.$ac_objext'
3628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3629   (eval $ac_try) 2>&5
3630   ac_status=$?
3631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3632   (exit $ac_status); }; }; then
3633   ac_cv_prog_cc_g=yes
3634 else
3635   echo "$as_me: failed program was:" >&5
3636 sed 's/^/| /' conftest.$ac_ext >&5
3637
3638 ac_cv_prog_cc_g=no
3639 fi
3640 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3641 fi
3642 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3643 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3644 if test "$ac_test_CFLAGS" = set; then
3645   CFLAGS=$ac_save_CFLAGS
3646 elif test $ac_cv_prog_cc_g = yes; then
3647   if test "$GCC" = yes; then
3648     CFLAGS="-g -O2"
3649   else
3650     CFLAGS="-g"
3651   fi
3652 else
3653   if test "$GCC" = yes; then
3654     CFLAGS="-O2"
3655   else
3656     CFLAGS=
3657   fi
3658 fi
3659 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3660 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3661 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3662   echo $ECHO_N "(cached) $ECHO_C" >&6
3663 else
3664   ac_cv_prog_cc_stdc=no
3665 ac_save_CC=$CC
3666 cat >conftest.$ac_ext <<_ACEOF
3667 /* confdefs.h.  */
3668 _ACEOF
3669 cat confdefs.h >>conftest.$ac_ext
3670 cat >>conftest.$ac_ext <<_ACEOF
3671 /* end confdefs.h.  */
3672 #include <stdarg.h>
3673 #include <stdio.h>
3674 #include <sys/types.h>
3675 #include <sys/stat.h>
3676 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3677 struct buf { int x; };
3678 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3679 static char *e (p, i)
3680      char **p;
3681      int i;
3682 {
3683   return p[i];
3684 }
3685 static char *f (char * (*g) (char **, int), char **p, ...)
3686 {
3687   char *s;
3688   va_list v;
3689   va_start (v,p);
3690   s = g (p, va_arg (v,int));
3691   va_end (v);
3692   return s;
3693 }
3694
3695 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3696    function prototypes and stuff, but not '\xHH' hex character constants.
3697    These don't provoke an error unfortunately, instead are silently treated
3698    as 'x'.  The following induces an error, until -std1 is added to get
3699    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3700    array size at least.  It's necessary to write '\x00'==0 to get something
3701    that's true only with -std1.  */
3702 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3703
3704 int test (int i, double x);
3705 struct s1 {int (*f) (int a);};
3706 struct s2 {int (*f) (double a);};
3707 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3708 int argc;
3709 char **argv;
3710 int
3711 main ()
3712 {
3713 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3714   ;
3715   return 0;
3716 }
3717 _ACEOF
3718 # Don't try gcc -ansi; that turns off useful extensions and
3719 # breaks some systems' header files.
3720 # AIX                   -qlanglvl=ansi
3721 # Ultrix and OSF/1      -std1
3722 # HP-UX 10.20 and later -Ae
3723 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3724 # SVR4                  -Xc -D__EXTENSIONS__
3725 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3726 do
3727   CC="$ac_save_CC $ac_arg"
3728   rm -f conftest.$ac_objext
3729 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3730   (eval $ac_compile) 2>conftest.er1
3731   ac_status=$?
3732   grep -v '^ *+' conftest.er1 >conftest.err
3733   rm -f conftest.er1
3734   cat conftest.err >&5
3735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3736   (exit $ac_status); } &&
3737          { ac_try='test -z "$ac_c_werror_flag"
3738                          || test ! -s conftest.err'
3739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3740   (eval $ac_try) 2>&5
3741   ac_status=$?
3742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3743   (exit $ac_status); }; } &&
3744          { ac_try='test -s conftest.$ac_objext'
3745   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3746   (eval $ac_try) 2>&5
3747   ac_status=$?
3748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3749   (exit $ac_status); }; }; then
3750   ac_cv_prog_cc_stdc=$ac_arg
3751 break
3752 else
3753   echo "$as_me: failed program was:" >&5
3754 sed 's/^/| /' conftest.$ac_ext >&5
3755
3756 fi
3757 rm -f conftest.err conftest.$ac_objext
3758 done
3759 rm -f conftest.$ac_ext conftest.$ac_objext
3760 CC=$ac_save_CC
3761
3762 fi
3763
3764 case "x$ac_cv_prog_cc_stdc" in
3765   x|xno)
3766     echo "$as_me:$LINENO: result: none needed" >&5
3767 echo "${ECHO_T}none needed" >&6 ;;
3768   *)
3769     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3770 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3771     CC="$CC $ac_cv_prog_cc_stdc" ;;
3772 esac
3773
3774 # Some people use a C++ compiler to compile C.  Since we use `exit',
3775 # in C++ we need to declare it.  In case someone uses the same compiler
3776 # for both compiling C and C++ we need to have the C++ compiler decide
3777 # the declaration of exit, since it's the most demanding environment.
3778 cat >conftest.$ac_ext <<_ACEOF
3779 #ifndef __cplusplus
3780   choke me
3781 #endif
3782 _ACEOF
3783 rm -f conftest.$ac_objext
3784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785   (eval $ac_compile) 2>conftest.er1
3786   ac_status=$?
3787   grep -v '^ *+' conftest.er1 >conftest.err
3788   rm -f conftest.er1
3789   cat conftest.err >&5
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); } &&
3792          { ac_try='test -z "$ac_c_werror_flag"
3793                          || test ! -s conftest.err'
3794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3795   (eval $ac_try) 2>&5
3796   ac_status=$?
3797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3798   (exit $ac_status); }; } &&
3799          { ac_try='test -s conftest.$ac_objext'
3800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3801   (eval $ac_try) 2>&5
3802   ac_status=$?
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); }; }; then
3805   for ac_declaration in \
3806    '' \
3807    'extern "C" void std::exit (int) throw (); using std::exit;' \
3808    'extern "C" void std::exit (int); using std::exit;' \
3809    'extern "C" void exit (int) throw ();' \
3810    'extern "C" void exit (int);' \
3811    'void exit (int);'
3812 do
3813   cat >conftest.$ac_ext <<_ACEOF
3814 /* confdefs.h.  */
3815 _ACEOF
3816 cat confdefs.h >>conftest.$ac_ext
3817 cat >>conftest.$ac_ext <<_ACEOF
3818 /* end confdefs.h.  */
3819 $ac_declaration
3820 #include <stdlib.h>
3821 int
3822 main ()
3823 {
3824 exit (42);
3825   ;
3826   return 0;
3827 }
3828 _ACEOF
3829 rm -f conftest.$ac_objext
3830 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3831   (eval $ac_compile) 2>conftest.er1
3832   ac_status=$?
3833   grep -v '^ *+' conftest.er1 >conftest.err
3834   rm -f conftest.er1
3835   cat conftest.err >&5
3836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3837   (exit $ac_status); } &&
3838          { ac_try='test -z "$ac_c_werror_flag"
3839                          || test ! -s conftest.err'
3840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3841   (eval $ac_try) 2>&5
3842   ac_status=$?
3843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3844   (exit $ac_status); }; } &&
3845          { ac_try='test -s conftest.$ac_objext'
3846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3847   (eval $ac_try) 2>&5
3848   ac_status=$?
3849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3850   (exit $ac_status); }; }; then
3851   :
3852 else
3853   echo "$as_me: failed program was:" >&5
3854 sed 's/^/| /' conftest.$ac_ext >&5
3855
3856 continue
3857 fi
3858 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3859   cat >conftest.$ac_ext <<_ACEOF
3860 /* confdefs.h.  */
3861 _ACEOF
3862 cat confdefs.h >>conftest.$ac_ext
3863 cat >>conftest.$ac_ext <<_ACEOF
3864 /* end confdefs.h.  */
3865 $ac_declaration
3866 int
3867 main ()
3868 {
3869 exit (42);
3870   ;
3871   return 0;
3872 }
3873 _ACEOF
3874 rm -f conftest.$ac_objext
3875 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3876   (eval $ac_compile) 2>conftest.er1
3877   ac_status=$?
3878   grep -v '^ *+' conftest.er1 >conftest.err
3879   rm -f conftest.er1
3880   cat conftest.err >&5
3881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3882   (exit $ac_status); } &&
3883          { ac_try='test -z "$ac_c_werror_flag"
3884                          || test ! -s conftest.err'
3885   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3886   (eval $ac_try) 2>&5
3887   ac_status=$?
3888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3889   (exit $ac_status); }; } &&
3890          { ac_try='test -s conftest.$ac_objext'
3891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3892   (eval $ac_try) 2>&5
3893   ac_status=$?
3894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3895   (exit $ac_status); }; }; then
3896   break
3897 else
3898   echo "$as_me: failed program was:" >&5
3899 sed 's/^/| /' conftest.$ac_ext >&5
3900
3901 fi
3902 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3903 done
3904 rm -f conftest*
3905 if test -n "$ac_declaration"; then
3906   echo '#ifdef __cplusplus' >>confdefs.h
3907   echo $ac_declaration      >>confdefs.h
3908   echo '#endif'             >>confdefs.h
3909 fi
3910
3911 else
3912   echo "$as_me: failed program was:" >&5
3913 sed 's/^/| /' conftest.$ac_ext >&5
3914
3915 fi
3916 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3917 ac_ext=c
3918 ac_cpp='$CPP $CPPFLAGS'
3919 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3920 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3921 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3922
3923 ac_ext=cc
3924 ac_cpp='$CXXCPP $CPPFLAGS'
3925 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3926 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3927 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3928 if test -n "$ac_tool_prefix"; then
3929   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3930   do
3931     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3932 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3933 echo "$as_me:$LINENO: checking for $ac_word" >&5
3934 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3935 if test "${ac_cv_prog_CXX+set}" = set; then
3936   echo $ECHO_N "(cached) $ECHO_C" >&6
3937 else
3938   if test -n "$CXX"; then
3939   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3940 else
3941 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3942 for as_dir in $PATH
3943 do
3944   IFS=$as_save_IFS
3945   test -z "$as_dir" && as_dir=.
3946   for ac_exec_ext in '' $ac_executable_extensions; do
3947   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3948     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3949     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3950     break 2
3951   fi
3952 done
3953 done
3954
3955 fi
3956 fi
3957 CXX=$ac_cv_prog_CXX
3958 if test -n "$CXX"; then
3959   echo "$as_me:$LINENO: result: $CXX" >&5
3960 echo "${ECHO_T}$CXX" >&6
3961 else
3962   echo "$as_me:$LINENO: result: no" >&5
3963 echo "${ECHO_T}no" >&6
3964 fi
3965
3966     test -n "$CXX" && break
3967   done
3968 fi
3969 if test -z "$CXX"; then
3970   ac_ct_CXX=$CXX
3971   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3972 do
3973   # Extract the first word of "$ac_prog", so it can be a program name with args.
3974 set dummy $ac_prog; ac_word=$2
3975 echo "$as_me:$LINENO: checking for $ac_word" >&5
3976 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3977 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3978   echo $ECHO_N "(cached) $ECHO_C" >&6
3979 else
3980   if test -n "$ac_ct_CXX"; then
3981   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3982 else
3983 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3984 for as_dir in $PATH
3985 do
3986   IFS=$as_save_IFS
3987   test -z "$as_dir" && as_dir=.
3988   for ac_exec_ext in '' $ac_executable_extensions; do
3989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3990     ac_cv_prog_ac_ct_CXX="$ac_prog"
3991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3992     break 2
3993   fi
3994 done
3995 done
3996
3997 fi
3998 fi
3999 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
4000 if test -n "$ac_ct_CXX"; then
4001   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
4002 echo "${ECHO_T}$ac_ct_CXX" >&6
4003 else
4004   echo "$as_me:$LINENO: result: no" >&5
4005 echo "${ECHO_T}no" >&6
4006 fi
4007
4008   test -n "$ac_ct_CXX" && break
4009 done
4010 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
4011
4012   CXX=$ac_ct_CXX
4013 fi
4014
4015
4016 # Provide some information about the compiler.
4017 echo "$as_me:$LINENO:" \
4018      "checking for C++ compiler version" >&5
4019 ac_compiler=`set X $ac_compile; echo $2`
4020 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4021   (eval $ac_compiler --version </dev/null >&5) 2>&5
4022   ac_status=$?
4023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4024   (exit $ac_status); }
4025 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4026   (eval $ac_compiler -v </dev/null >&5) 2>&5
4027   ac_status=$?
4028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4029   (exit $ac_status); }
4030 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4031   (eval $ac_compiler -V </dev/null >&5) 2>&5
4032   ac_status=$?
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); }
4035
4036 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4037 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4038 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4039   echo $ECHO_N "(cached) $ECHO_C" >&6
4040 else
4041   cat >conftest.$ac_ext <<_ACEOF
4042 /* confdefs.h.  */
4043 _ACEOF
4044 cat confdefs.h >>conftest.$ac_ext
4045 cat >>conftest.$ac_ext <<_ACEOF
4046 /* end confdefs.h.  */
4047
4048 int
4049 main ()
4050 {
4051 #ifndef __GNUC__
4052        choke me
4053 #endif
4054
4055   ;
4056   return 0;
4057 }
4058 _ACEOF
4059 rm -f conftest.$ac_objext
4060 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4061   (eval $ac_compile) 2>conftest.er1
4062   ac_status=$?
4063   grep -v '^ *+' conftest.er1 >conftest.err
4064   rm -f conftest.er1
4065   cat conftest.err >&5
4066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4067   (exit $ac_status); } &&
4068          { ac_try='test -z "$ac_cxx_werror_flag"
4069                          || test ! -s conftest.err'
4070   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4071   (eval $ac_try) 2>&5
4072   ac_status=$?
4073   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4074   (exit $ac_status); }; } &&
4075          { ac_try='test -s conftest.$ac_objext'
4076   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4077   (eval $ac_try) 2>&5
4078   ac_status=$?
4079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4080   (exit $ac_status); }; }; then
4081   ac_compiler_gnu=yes
4082 else
4083   echo "$as_me: failed program was:" >&5
4084 sed 's/^/| /' conftest.$ac_ext >&5
4085
4086 ac_compiler_gnu=no
4087 fi
4088 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4090
4091 fi
4092 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4093 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4094 GXX=`test $ac_compiler_gnu = yes && echo yes`
4095 ac_test_CXXFLAGS=${CXXFLAGS+set}
4096 ac_save_CXXFLAGS=$CXXFLAGS
4097 CXXFLAGS="-g"
4098 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4099 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4100 if test "${ac_cv_prog_cxx_g+set}" = set; then
4101   echo $ECHO_N "(cached) $ECHO_C" >&6
4102 else
4103   cat >conftest.$ac_ext <<_ACEOF
4104 /* confdefs.h.  */
4105 _ACEOF
4106 cat confdefs.h >>conftest.$ac_ext
4107 cat >>conftest.$ac_ext <<_ACEOF
4108 /* end confdefs.h.  */
4109
4110 int
4111 main ()
4112 {
4113
4114   ;
4115   return 0;
4116 }
4117 _ACEOF
4118 rm -f conftest.$ac_objext
4119 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4120   (eval $ac_compile) 2>conftest.er1
4121   ac_status=$?
4122   grep -v '^ *+' conftest.er1 >conftest.err
4123   rm -f conftest.er1
4124   cat conftest.err >&5
4125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4126   (exit $ac_status); } &&
4127          { ac_try='test -z "$ac_cxx_werror_flag"
4128                          || test ! -s conftest.err'
4129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4130   (eval $ac_try) 2>&5
4131   ac_status=$?
4132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4133   (exit $ac_status); }; } &&
4134          { ac_try='test -s conftest.$ac_objext'
4135   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4136   (eval $ac_try) 2>&5
4137   ac_status=$?
4138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4139   (exit $ac_status); }; }; then
4140   ac_cv_prog_cxx_g=yes
4141 else
4142   echo "$as_me: failed program was:" >&5
4143 sed 's/^/| /' conftest.$ac_ext >&5
4144
4145 ac_cv_prog_cxx_g=no
4146 fi
4147 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4148 fi
4149 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4150 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4151 if test "$ac_test_CXXFLAGS" = set; then
4152   CXXFLAGS=$ac_save_CXXFLAGS
4153 elif test $ac_cv_prog_cxx_g = yes; then
4154   if test "$GXX" = yes; then
4155     CXXFLAGS="-g -O2"
4156   else
4157     CXXFLAGS="-g"
4158   fi
4159 else
4160   if test "$GXX" = yes; then
4161     CXXFLAGS="-O2"
4162   else
4163     CXXFLAGS=
4164   fi
4165 fi
4166 for ac_declaration in \
4167    '' \
4168    'extern "C" void std::exit (int) throw (); using std::exit;' \
4169    'extern "C" void std::exit (int); using std::exit;' \
4170    'extern "C" void exit (int) throw ();' \
4171    'extern "C" void exit (int);' \
4172    'void exit (int);'
4173 do
4174   cat >conftest.$ac_ext <<_ACEOF
4175 /* confdefs.h.  */
4176 _ACEOF
4177 cat confdefs.h >>conftest.$ac_ext
4178 cat >>conftest.$ac_ext <<_ACEOF
4179 /* end confdefs.h.  */
4180 $ac_declaration
4181 #include <stdlib.h>
4182 int
4183 main ()
4184 {
4185 exit (42);
4186   ;
4187   return 0;
4188 }
4189 _ACEOF
4190 rm -f conftest.$ac_objext
4191 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4192   (eval $ac_compile) 2>conftest.er1
4193   ac_status=$?
4194   grep -v '^ *+' conftest.er1 >conftest.err
4195   rm -f conftest.er1
4196   cat conftest.err >&5
4197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4198   (exit $ac_status); } &&
4199          { ac_try='test -z "$ac_cxx_werror_flag"
4200                          || test ! -s conftest.err'
4201   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4202   (eval $ac_try) 2>&5
4203   ac_status=$?
4204   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4205   (exit $ac_status); }; } &&
4206          { ac_try='test -s conftest.$ac_objext'
4207   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4208   (eval $ac_try) 2>&5
4209   ac_status=$?
4210   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4211   (exit $ac_status); }; }; then
4212   :
4213 else
4214   echo "$as_me: failed program was:" >&5
4215 sed 's/^/| /' conftest.$ac_ext >&5
4216
4217 continue
4218 fi
4219 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4220   cat >conftest.$ac_ext <<_ACEOF
4221 /* confdefs.h.  */
4222 _ACEOF
4223 cat confdefs.h >>conftest.$ac_ext
4224 cat >>conftest.$ac_ext <<_ACEOF
4225 /* end confdefs.h.  */
4226 $ac_declaration
4227 int
4228 main ()
4229 {
4230 exit (42);
4231   ;
4232   return 0;
4233 }
4234 _ACEOF
4235 rm -f conftest.$ac_objext
4236 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4237   (eval $ac_compile) 2>conftest.er1
4238   ac_status=$?
4239   grep -v '^ *+' conftest.er1 >conftest.err
4240   rm -f conftest.er1
4241   cat conftest.err >&5
4242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4243   (exit $ac_status); } &&
4244          { ac_try='test -z "$ac_cxx_werror_flag"
4245                          || test ! -s conftest.err'
4246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4247   (eval $ac_try) 2>&5
4248   ac_status=$?
4249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4250   (exit $ac_status); }; } &&
4251          { ac_try='test -s conftest.$ac_objext'
4252   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4253   (eval $ac_try) 2>&5
4254   ac_status=$?
4255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4256   (exit $ac_status); }; }; then
4257   break
4258 else
4259   echo "$as_me: failed program was:" >&5
4260 sed 's/^/| /' conftest.$ac_ext >&5
4261
4262 fi
4263 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4264 done
4265 rm -f conftest*
4266 if test -n "$ac_declaration"; then
4267   echo '#ifdef __cplusplus' >>confdefs.h
4268   echo $ac_declaration      >>confdefs.h
4269   echo '#endif'             >>confdefs.h
4270 fi
4271
4272 ac_ext=c
4273 ac_cpp='$CPP $CPPFLAGS'
4274 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4275 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4276 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4277
4278
4279 # We must set the default linker to the linker used by gcc for the correct
4280 # operation of libtool.  If LD is not defined and we are using gcc, try to
4281 # set the LD default to the ld used by gcc.
4282 if test -z "$LD"; then
4283   if test "$GCC" = yes; then
4284     case $build in
4285     *-*-mingw*)
4286       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4287     *)
4288       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4289     esac
4290     case $gcc_prog_ld in
4291     # Accept absolute paths.
4292     [\\/]* | [A-Za-z]:[\\/]*)
4293       LD="$gcc_prog_ld" ;;
4294     esac
4295   fi
4296 fi
4297
4298
4299
4300
4301 if test -n "$ac_tool_prefix"; then
4302   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4303 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4304 echo "$as_me:$LINENO: checking for $ac_word" >&5
4305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4306 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4307   echo $ECHO_N "(cached) $ECHO_C" >&6
4308 else
4309   if test -n "$GNATBIND"; then
4310   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4311 else
4312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4313 for as_dir in $PATH
4314 do
4315   IFS=$as_save_IFS
4316   test -z "$as_dir" && as_dir=.
4317   for ac_exec_ext in '' $ac_executable_extensions; do
4318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4319     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4321     break 2
4322   fi
4323 done
4324 done
4325
4326 fi
4327 fi
4328 GNATBIND=$ac_cv_prog_GNATBIND
4329 if test -n "$GNATBIND"; then
4330   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4331 echo "${ECHO_T}$GNATBIND" >&6
4332 else
4333   echo "$as_me:$LINENO: result: no" >&5
4334 echo "${ECHO_T}no" >&6
4335 fi
4336
4337 fi
4338 if test -z "$ac_cv_prog_GNATBIND"; then
4339   ac_ct_GNATBIND=$GNATBIND
4340   # Extract the first word of "gnatbind", so it can be a program name with args.
4341 set dummy gnatbind; ac_word=$2
4342 echo "$as_me:$LINENO: checking for $ac_word" >&5
4343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4344 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4345   echo $ECHO_N "(cached) $ECHO_C" >&6
4346 else
4347   if test -n "$ac_ct_GNATBIND"; then
4348   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4349 else
4350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4351 for as_dir in $PATH
4352 do
4353   IFS=$as_save_IFS
4354   test -z "$as_dir" && as_dir=.
4355   for ac_exec_ext in '' $ac_executable_extensions; do
4356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4357     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4359     break 2
4360   fi
4361 done
4362 done
4363
4364   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4365 fi
4366 fi
4367 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4368 if test -n "$ac_ct_GNATBIND"; then
4369   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4370 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4371 else
4372   echo "$as_me:$LINENO: result: no" >&5
4373 echo "${ECHO_T}no" >&6
4374 fi
4375
4376   GNATBIND=$ac_ct_GNATBIND
4377 else
4378   GNATBIND="$ac_cv_prog_GNATBIND"
4379 fi
4380
4381 if test -n "$ac_tool_prefix"; then
4382   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4383 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4384 echo "$as_me:$LINENO: checking for $ac_word" >&5
4385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4386 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4387   echo $ECHO_N "(cached) $ECHO_C" >&6
4388 else
4389   if test -n "$GNATMAKE"; then
4390   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4391 else
4392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4393 for as_dir in $PATH
4394 do
4395   IFS=$as_save_IFS
4396   test -z "$as_dir" && as_dir=.
4397   for ac_exec_ext in '' $ac_executable_extensions; do
4398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4399     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4401     break 2
4402   fi
4403 done
4404 done
4405
4406 fi
4407 fi
4408 GNATMAKE=$ac_cv_prog_GNATMAKE
4409 if test -n "$GNATMAKE"; then
4410   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4411 echo "${ECHO_T}$GNATMAKE" >&6
4412 else
4413   echo "$as_me:$LINENO: result: no" >&5
4414 echo "${ECHO_T}no" >&6
4415 fi
4416
4417 fi
4418 if test -z "$ac_cv_prog_GNATMAKE"; then
4419   ac_ct_GNATMAKE=$GNATMAKE
4420   # Extract the first word of "gnatmake", so it can be a program name with args.
4421 set dummy gnatmake; ac_word=$2
4422 echo "$as_me:$LINENO: checking for $ac_word" >&5
4423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4424 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4425   echo $ECHO_N "(cached) $ECHO_C" >&6
4426 else
4427   if test -n "$ac_ct_GNATMAKE"; then
4428   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4429 else
4430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4431 for as_dir in $PATH
4432 do
4433   IFS=$as_save_IFS
4434   test -z "$as_dir" && as_dir=.
4435   for ac_exec_ext in '' $ac_executable_extensions; do
4436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4437     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4439     break 2
4440   fi
4441 done
4442 done
4443
4444   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4445 fi
4446 fi
4447 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4448 if test -n "$ac_ct_GNATMAKE"; then
4449   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4450 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4451 else
4452   echo "$as_me:$LINENO: result: no" >&5
4453 echo "${ECHO_T}no" >&6
4454 fi
4455
4456   GNATMAKE=$ac_ct_GNATMAKE
4457 else
4458   GNATMAKE="$ac_cv_prog_GNATMAKE"
4459 fi
4460
4461 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4462 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4463 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4464   echo $ECHO_N "(cached) $ECHO_C" >&6
4465 else
4466   cat >conftest.adb <<EOF
4467 procedure conftest is begin null; end conftest;
4468 EOF
4469 acx_cv_cc_gcc_supports_ada=no
4470 # There is a bug in old released versions of GCC which causes the
4471 # driver to exit successfully when the appropriate language module
4472 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4473 # Therefore we must check for the error message as well as an
4474 # unsuccessful exit.
4475 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4476 # given a .adb file, but produce no object file.  So we must check
4477 # if an object file was really produced to guard against this.
4478 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4479 if test x"$errors" = x && test -f conftest.$ac_objext; then
4480   acx_cv_cc_gcc_supports_ada=yes
4481 fi
4482 rm -f conftest.*
4483 fi
4484 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4485 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4486
4487 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4488   have_gnat=yes
4489 else
4490   have_gnat=no
4491 fi
4492
4493 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4494 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4495 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4496   echo $ECHO_N "(cached) $ECHO_C" >&6
4497 else
4498    echo abfoo >t1
4499   echo cdfoo >t2
4500   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4501   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4502     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4503       :
4504     else
4505       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4506     fi
4507   fi
4508   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4509     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4510       :
4511     else
4512       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4513     fi
4514   fi
4515   rm t1 t2
4516
4517 fi
4518 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4519 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4520 do_compare="$gcc_cv_prog_cmp_skip"
4521
4522
4523
4524 # See if we are building gcc with C++.
4525 # Check whether --enable-build-with-cxx or --disable-build-with-cxx was given.
4526 if test "${enable_build_with_cxx+set}" = set; then
4527   enableval="$enable_build_with_cxx"
4528   ENABLE_BUILD_WITH_CXX=$enableval
4529 else
4530   ENABLE_BUILD_WITH_CXX=no
4531 fi;
4532
4533 # Check for GMP, MPFR and MPC
4534 gmplibs="-lmpfr -lgmp"
4535 gmpinc=
4536 have_gmp=no
4537 mpclibs=-lmpc
4538 mpcinc=
4539 have_mpc=no
4540
4541 # Specify a location for mpc
4542 # check for this first so it ends up on the link line before mpfr.
4543
4544 # Check whether --with-mpc or --without-mpc was given.
4545 if test "${with_mpc+set}" = set; then
4546   withval="$with_mpc"
4547
4548 fi;
4549
4550 # Check whether --with-mpc_include or --without-mpc_include was given.
4551 if test "${with_mpc_include+set}" = set; then
4552   withval="$with_mpc_include"
4553
4554 fi;
4555
4556 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4557 if test "${with_mpc_lib+set}" = set; then
4558   withval="$with_mpc_lib"
4559
4560 fi;
4561
4562 if test "x$with_mpc" != x; then
4563   mpclibs="-L$with_mpc/lib -lmpc"
4564   mpcinc="-I$with_mpc/include $mpcinc"
4565 fi
4566 if test "x$with_mpc_include" != x; then
4567   mpcinc="-I$with_mpc_include $mpcinc"
4568 fi
4569 if test "x$with_mpc_lib" != x; then
4570   mpclibs="-L$with_mpc_lib -lmpc"
4571 fi
4572 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4573   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4574   mpcinc='-I$$s/mpc/src '"$mpcinc"
4575   # Do not test the mpc version.  Assume that it is sufficient, since
4576   # it is in the source tree, and the library has not been built yet
4577   # but it would be included on the link line in the version check below
4578   # hence making the test fail.
4579   have_mpc=yes
4580 fi
4581
4582 # Specify a location for mpfr
4583 # check for this first so it ends up on the link line before gmp.
4584
4585 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4586 if test "${with_mpfr_dir+set}" = set; then
4587   withval="$with_mpfr_dir"
4588   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4589 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4590 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4591 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4592    { (exit 1); exit 1; }; }
4593 fi;
4594
4595
4596 # Check whether --with-mpfr or --without-mpfr was given.
4597 if test "${with_mpfr+set}" = set; then
4598   withval="$with_mpfr"
4599
4600 fi;
4601
4602 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4603 if test "${with_mpfr_include+set}" = set; then
4604   withval="$with_mpfr_include"
4605
4606 fi;
4607
4608 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4609 if test "${with_mpfr_lib+set}" = set; then
4610   withval="$with_mpfr_lib"
4611
4612 fi;
4613
4614 if test "x$with_mpfr" != x; then
4615   gmplibs="-L$with_mpfr/lib $gmplibs"
4616   gmpinc="-I$with_mpfr/include"
4617 fi
4618 if test "x$with_mpfr_include" != x; then
4619   gmpinc="-I$with_mpfr_include"
4620 fi
4621 if test "x$with_mpfr_lib" != x; then
4622   gmplibs="-L$with_mpfr_lib $gmplibs"
4623 fi
4624 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4625   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4626   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4627   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4628   # Do not test the mpfr version.  Assume that it is sufficient, since
4629   # it is in the source tree, and the library has not been built yet
4630   # but it would be included on the link line in the version check below
4631   # hence making the test fail.
4632   have_gmp=yes
4633 fi
4634
4635 # Specify a location for gmp
4636
4637 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4638 if test "${with_gmp_dir+set}" = set; then
4639   withval="$with_gmp_dir"
4640   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4641 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4642 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4643 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4644    { (exit 1); exit 1; }; }
4645 fi;
4646
4647
4648 # Check whether --with-gmp or --without-gmp was given.
4649 if test "${with_gmp+set}" = set; then
4650   withval="$with_gmp"
4651
4652 fi;
4653
4654 # Check whether --with-gmp_include or --without-gmp_include was given.
4655 if test "${with_gmp_include+set}" = set; then
4656   withval="$with_gmp_include"
4657
4658 fi;
4659
4660 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4661 if test "${with_gmp_lib+set}" = set; then
4662   withval="$with_gmp_lib"
4663
4664 fi;
4665
4666
4667 if test "x$with_gmp" != x; then
4668   gmplibs="-L$with_gmp/lib $gmplibs"
4669   gmpinc="-I$with_gmp/include $gmpinc"
4670 fi
4671 if test "x$with_gmp_include" != x; then
4672   gmpinc="-I$with_gmp_include $gmpinc"
4673 fi
4674 if test "x$with_gmp_lib" != x; then
4675   gmplibs="-L$with_gmp_lib $gmplibs"
4676 fi
4677 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4678   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4679   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4680   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4681   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4682   # Do not test the gmp version.  Assume that it is sufficient, since
4683   # it is in the source tree, and the library has not been built yet
4684   # but it would be included on the link line in the version check below
4685   # hence making the test fail.
4686   have_gmp=yes
4687 fi
4688
4689 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4690   have_gmp=yes
4691   saved_CFLAGS="$CFLAGS"
4692   CFLAGS="$CFLAGS $gmpinc"
4693   # Check GMP actually works
4694   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4695 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4696
4697 cat >conftest.$ac_ext <<_ACEOF
4698 /* confdefs.h.  */
4699 _ACEOF
4700 cat confdefs.h >>conftest.$ac_ext
4701 cat >>conftest.$ac_ext <<_ACEOF
4702 /* end confdefs.h.  */
4703 #include "gmp.h"
4704 int
4705 main ()
4706 {
4707
4708   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4709   choke me
4710   #endif
4711
4712   ;
4713   return 0;
4714 }
4715 _ACEOF
4716 rm -f conftest.$ac_objext
4717 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4718   (eval $ac_compile) 2>conftest.er1
4719   ac_status=$?
4720   grep -v '^ *+' conftest.er1 >conftest.err
4721   rm -f conftest.er1
4722   cat conftest.err >&5
4723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4724   (exit $ac_status); } &&
4725          { ac_try='test -z "$ac_c_werror_flag"
4726                          || test ! -s conftest.err'
4727   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4728   (eval $ac_try) 2>&5
4729   ac_status=$?
4730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4731   (exit $ac_status); }; } &&
4732          { ac_try='test -s conftest.$ac_objext'
4733   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4734   (eval $ac_try) 2>&5
4735   ac_status=$?
4736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4737   (exit $ac_status); }; }; then
4738   echo "$as_me:$LINENO: result: yes" >&5
4739 echo "${ECHO_T}yes" >&6
4740 else
4741   echo "$as_me: failed program was:" >&5
4742 sed 's/^/| /' conftest.$ac_ext >&5
4743
4744 echo "$as_me:$LINENO: result: no" >&5
4745 echo "${ECHO_T}no" >&6; have_gmp=no
4746 fi
4747 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4748
4749   # If we have GMP, check the MPFR version.
4750   if test x"$have_gmp" = xyes; then
4751         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4752 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4753     cat >conftest.$ac_ext <<_ACEOF
4754 /* confdefs.h.  */
4755 _ACEOF
4756 cat confdefs.h >>conftest.$ac_ext
4757 cat >>conftest.$ac_ext <<_ACEOF
4758 /* end confdefs.h.  */
4759 #include <gmp.h>
4760     #include <mpfr.h>
4761 int
4762 main ()
4763 {
4764
4765     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4766     choke me
4767     #endif
4768
4769   ;
4770   return 0;
4771 }
4772 _ACEOF
4773 rm -f conftest.$ac_objext
4774 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4775   (eval $ac_compile) 2>conftest.er1
4776   ac_status=$?
4777   grep -v '^ *+' conftest.er1 >conftest.err
4778   rm -f conftest.er1
4779   cat conftest.err >&5
4780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4781   (exit $ac_status); } &&
4782          { ac_try='test -z "$ac_c_werror_flag"
4783                          || test ! -s conftest.err'
4784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4785   (eval $ac_try) 2>&5
4786   ac_status=$?
4787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4788   (exit $ac_status); }; } &&
4789          { ac_try='test -s conftest.$ac_objext'
4790   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4791   (eval $ac_try) 2>&5
4792   ac_status=$?
4793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4794   (exit $ac_status); }; }; then
4795   cat >conftest.$ac_ext <<_ACEOF
4796 /* confdefs.h.  */
4797 _ACEOF
4798 cat confdefs.h >>conftest.$ac_ext
4799 cat >>conftest.$ac_ext <<_ACEOF
4800 /* end confdefs.h.  */
4801 #include <gmp.h>
4802     #include <mpfr.h>
4803 int
4804 main ()
4805 {
4806
4807     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4808     choke me
4809     #endif
4810
4811   ;
4812   return 0;
4813 }
4814 _ACEOF
4815 rm -f conftest.$ac_objext
4816 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4817   (eval $ac_compile) 2>conftest.er1
4818   ac_status=$?
4819   grep -v '^ *+' conftest.er1 >conftest.err
4820   rm -f conftest.er1
4821   cat conftest.err >&5
4822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4823   (exit $ac_status); } &&
4824          { ac_try='test -z "$ac_c_werror_flag"
4825                          || test ! -s conftest.err'
4826   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4827   (eval $ac_try) 2>&5
4828   ac_status=$?
4829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4830   (exit $ac_status); }; } &&
4831          { ac_try='test -s conftest.$ac_objext'
4832   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4833   (eval $ac_try) 2>&5
4834   ac_status=$?
4835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4836   (exit $ac_status); }; }; then
4837   echo "$as_me:$LINENO: result: yes" >&5
4838 echo "${ECHO_T}yes" >&6
4839 else
4840   echo "$as_me: failed program was:" >&5
4841 sed 's/^/| /' conftest.$ac_ext >&5
4842
4843 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4844 echo "${ECHO_T}buggy but acceptable" >&6
4845 fi
4846 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4847 else
4848   echo "$as_me: failed program was:" >&5
4849 sed 's/^/| /' conftest.$ac_ext >&5
4850
4851 echo "$as_me:$LINENO: result: no" >&5
4852 echo "${ECHO_T}no" >&6; have_gmp=no
4853 fi
4854 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4855   fi
4856
4857   # Check for the MPC header version.
4858   if test x"$have_mpc" != xyes ; then
4859     CFLAGS="$CFLAGS $mpcinc"
4860     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4861 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4862     cat >conftest.$ac_ext <<_ACEOF
4863 /* confdefs.h.  */
4864 _ACEOF
4865 cat confdefs.h >>conftest.$ac_ext
4866 cat >>conftest.$ac_ext <<_ACEOF
4867 /* end confdefs.h.  */
4868 #include <mpc.h>
4869 int
4870 main ()
4871 {
4872
4873     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4874     choke me
4875     #endif
4876
4877   ;
4878   return 0;
4879 }
4880 _ACEOF
4881 rm -f conftest.$ac_objext
4882 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4883   (eval $ac_compile) 2>conftest.er1
4884   ac_status=$?
4885   grep -v '^ *+' conftest.er1 >conftest.err
4886   rm -f conftest.er1
4887   cat conftest.err >&5
4888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4889   (exit $ac_status); } &&
4890          { ac_try='test -z "$ac_c_werror_flag"
4891                          || test ! -s conftest.err'
4892   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4893   (eval $ac_try) 2>&5
4894   ac_status=$?
4895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4896   (exit $ac_status); }; } &&
4897          { ac_try='test -s conftest.$ac_objext'
4898   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4899   (eval $ac_try) 2>&5
4900   ac_status=$?
4901   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4902   (exit $ac_status); }; }; then
4903   echo "$as_me:$LINENO: result: yes" >&5
4904 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4905 else
4906   echo "$as_me: failed program was:" >&5
4907 sed 's/^/| /' conftest.$ac_ext >&5
4908
4909 echo "$as_me:$LINENO: result: no" >&5
4910 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4911 fi
4912 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4913   fi
4914
4915   # Now check the MPFR library.
4916   if test x"$have_gmp" = xyes; then
4917     saved_LIBS="$LIBS"
4918     LIBS="$LIBS $gmplibs"
4919     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4920 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4921     cat >conftest.$ac_ext <<_ACEOF
4922 /* confdefs.h.  */
4923 _ACEOF
4924 cat confdefs.h >>conftest.$ac_ext
4925 cat >>conftest.$ac_ext <<_ACEOF
4926 /* end confdefs.h.  */
4927 #include <gmp.h>
4928     #include <mpfr.h>
4929 int
4930 main ()
4931 {
4932
4933     mpfr_t n;
4934     mpfr_t x;
4935     int t;
4936     mpfr_init (n);
4937     mpfr_init (x);
4938     mpfr_atan2 (n, n, x, GMP_RNDN);
4939     mpfr_erfc (n, x, GMP_RNDN);
4940     mpfr_subnormalize (x, t, GMP_RNDN);
4941
4942   ;
4943   return 0;
4944 }
4945 _ACEOF
4946 rm -f conftest.$ac_objext conftest$ac_exeext
4947 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4948   (eval $ac_link) 2>conftest.er1
4949   ac_status=$?
4950   grep -v '^ *+' conftest.er1 >conftest.err
4951   rm -f conftest.er1
4952   cat conftest.err >&5
4953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4954   (exit $ac_status); } &&
4955          { ac_try='test -z "$ac_c_werror_flag"
4956                          || test ! -s conftest.err'
4957   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4958   (eval $ac_try) 2>&5
4959   ac_status=$?
4960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4961   (exit $ac_status); }; } &&
4962          { ac_try='test -s conftest$ac_exeext'
4963   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4964   (eval $ac_try) 2>&5
4965   ac_status=$?
4966   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4967   (exit $ac_status); }; }; then
4968   echo "$as_me:$LINENO: result: yes" >&5
4969 echo "${ECHO_T}yes" >&6
4970 else
4971   echo "$as_me: failed program was:" >&5
4972 sed 's/^/| /' conftest.$ac_ext >&5
4973
4974 echo "$as_me:$LINENO: result: no" >&5
4975 echo "${ECHO_T}no" >&6; have_gmp=no
4976 fi
4977 rm -f conftest.err conftest.$ac_objext \
4978       conftest$ac_exeext conftest.$ac_ext
4979     LIBS="$saved_LIBS"
4980   fi
4981
4982   if test x"$have_mpc" = xmaybe; then
4983     saved_LIBS="$LIBS"
4984     LIBS="$LIBS $mpclibs $gmplibs"
4985     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4986 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4987     cat >conftest.$ac_ext <<_ACEOF
4988 /* confdefs.h.  */
4989 _ACEOF
4990 cat confdefs.h >>conftest.$ac_ext
4991 cat >>conftest.$ac_ext <<_ACEOF
4992 /* end confdefs.h.  */
4993 #include <mpc.h>
4994 int
4995 main ()
4996 {
4997
4998     mpc_t n;
4999     mpc_init2 (n, 53);
5000     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
5001     mpc_sin (n, n, MPC_RNDNN);
5002     mpc_cos (n, n, MPC_RNDNN);
5003     mpc_tan (n, n, MPC_RNDNN);
5004     mpc_sinh (n, n, MPC_RNDNN);
5005     mpc_cosh (n, n, MPC_RNDNN);
5006     mpc_tanh (n, n, MPC_RNDNN);
5007     mpc_exp (n, n, MPC_RNDNN);
5008     mpc_log (n, n, MPC_RNDNN);
5009     mpc_sqrt (n, n, MPC_RNDNN);
5010     mpc_proj (n, n, MPC_RNDNN);
5011     mpc_neg (n, n, MPC_RNDNN);
5012     mpc_sqr (n, n, MPC_RNDNN);
5013     mpc_clear (n);
5014
5015   ;
5016   return 0;
5017 }
5018 _ACEOF
5019 rm -f conftest.$ac_objext conftest$ac_exeext
5020 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5021   (eval $ac_link) 2>conftest.er1
5022   ac_status=$?
5023   grep -v '^ *+' conftest.er1 >conftest.err
5024   rm -f conftest.er1
5025   cat conftest.err >&5
5026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5027   (exit $ac_status); } &&
5028          { ac_try='test -z "$ac_c_werror_flag"
5029                          || test ! -s conftest.err'
5030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5031   (eval $ac_try) 2>&5
5032   ac_status=$?
5033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5034   (exit $ac_status); }; } &&
5035          { ac_try='test -s conftest$ac_exeext'
5036   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5037   (eval $ac_try) 2>&5
5038   ac_status=$?
5039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5040   (exit $ac_status); }; }; then
5041   echo "$as_me:$LINENO: result: yes" >&5
5042 echo "${ECHO_T}yes" >&6; have_mpc=yes
5043 else
5044   echo "$as_me: failed program was:" >&5
5045 sed 's/^/| /' conftest.$ac_ext >&5
5046
5047 echo "$as_me:$LINENO: result: no" >&5
5048 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5049 fi
5050 rm -f conftest.err conftest.$ac_objext \
5051       conftest$ac_exeext conftest.$ac_ext
5052     LIBS="$saved_LIBS"
5053   fi
5054
5055   CFLAGS="$saved_CFLAGS"
5056
5057   if test x$have_gmp != xyes; then
5058     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5059 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5060 Copies of these libraries' source code can be found at their respective
5061 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5062 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5063 If you obtained GMP and/or MPFR from a vendor distribution package, make
5064 sure that you have installed both the libraries and the header files.
5065 They may be located in separate packages." >&5
5066 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5067 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5068 Copies of these libraries' source code can be found at their respective
5069 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5070 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5071 If you obtained GMP and/or MPFR from a vendor distribution package, make
5072 sure that you have installed both the libraries and the header files.
5073 They may be located in separate packages." >&2;}
5074    { (exit 1); exit 1; }; }
5075   fi
5076 fi
5077
5078 if test x$have_mpc != xyes ; then
5079   mpcinc=
5080   mpclibs=
5081 fi
5082
5083 gmpinc="$mpcinc $gmpinc"
5084 gmplibs="$mpclibs $gmplibs"
5085
5086 # Flags needed for both GMP, MPFR and/or MPC.
5087
5088
5089
5090
5091
5092
5093 # Allow host libstdc++ to be specified for static linking with PPL.
5094
5095 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5096 if test "${with_host_libstdcxx+set}" = set; then
5097   withval="$with_host_libstdcxx"
5098
5099 fi;
5100
5101 case $with_host_libstdcxx in
5102   no|yes)
5103     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5104 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5105    { (exit 1); exit 1; }; }
5106     ;;
5107 esac
5108
5109 # Linker flags to use for stage1 or when not boostrapping.
5110
5111 # Check whether --with-stage1-ldflags or --without-stage1-ldflags was given.
5112 if test "${with_stage1_ldflags+set}" = set; then
5113   withval="$with_stage1_ldflags"
5114   if test "$withval" = "no" -o "$withval" = "yes"; then
5115    stage1_ldflags=
5116  else
5117    stage1_ldflags=$withval
5118  fi
5119 else
5120   stage1_ldflags=
5121 fi;
5122
5123
5124 # Libraries to use for stage1 or when not bootstrapping.
5125
5126 # Check whether --with-stage1-libs or --without-stage1-libs was given.
5127 if test "${with_stage1_libs+set}" = set; then
5128   withval="$with_stage1_libs"
5129   if test "$withval" = "no" -o "$withval" = "yes"; then
5130    stage1_libs=
5131  else
5132    stage1_libs=$withval
5133  fi
5134 else
5135   stage1_libs=$with_host_libstdcxx
5136 fi;
5137
5138
5139 # Linker flags to use for stage2 and later builds.
5140
5141 # Check whether --with-boot-ldflags or --without-boot-ldflags was given.
5142 if test "${with_boot_ldflags+set}" = set; then
5143   withval="$with_boot_ldflags"
5144   if test "$withval" = "no" -o "$withval" = "yes"; then
5145    poststage1_ldflags=
5146  else
5147    poststage1_ldflags=$withval
5148  fi
5149 else
5150   if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5151    poststage1_ldflags=-static-libstdc++
5152  else
5153    poststage1_ldflags=
5154  fi
5155 fi;
5156
5157
5158 # Libraries to use for stage2 and later builds.  This defaults to the
5159 # argument passed to --with-host-libstdcxx.
5160
5161 # Check whether --with-boot-libs or --without-boot-libs was given.
5162 if test "${with_boot_libs+set}" = set; then
5163   withval="$with_boot_libs"
5164   if test "$withval" = "no" -o "$withval" = "yes"; then
5165    poststage1_libs=
5166  else
5167    poststage1_libs=$withval
5168  fi
5169 else
5170   poststage1_libs=$with_host_libstdcxx
5171 fi;
5172
5173
5174 # Check for PPL
5175 ppl_major_version=0
5176 ppl_minor_version=10
5177 ppllibs=" -lppl_c -lppl -lgmpxx"
5178 pplinc=
5179
5180
5181 # Check whether --with-ppl or --without-ppl was given.
5182 if test "${with_ppl+set}" = set; then
5183   withval="$with_ppl"
5184
5185 else
5186   with_ppl=no
5187 fi;
5188
5189 # Check whether --with-ppl_include or --without-ppl_include was given.
5190 if test "${with_ppl_include+set}" = set; then
5191   withval="$with_ppl_include"
5192
5193 fi;
5194
5195 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5196 if test "${with_ppl_lib+set}" = set; then
5197   withval="$with_ppl_lib"
5198
5199 fi;
5200
5201 case $with_ppl in
5202   no)
5203     ppllibs=
5204     ;;
5205   *)
5206     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
5207     pplinc="-I$with_ppl/include $pplinc"
5208     LIBS="$ppllibs $LIBS"
5209     ;;
5210 esac
5211 if test "x$with_ppl_include" != x; then
5212   pplinc="-I$with_ppl_include $pplinc"
5213 fi
5214 if test "x$with_ppl_lib" != x; then
5215   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
5216   LIBS="$ppllibs $LIBS"
5217 fi
5218 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5219   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
5220   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5221   LIBS="$ppllibs $LIBS"
5222 fi
5223
5224 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5225 if test "${enable_ppl_version_check+set}" = set; then
5226   enableval="$enable_ppl_version_check"
5227   ENABLE_PPL_CHECK=$enableval
5228 else
5229   ENABLE_PPL_CHECK=yes
5230 fi;
5231
5232 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5233   saved_CFLAGS="$CFLAGS"
5234   CFLAGS="$CFLAGS $pplinc $gmpinc"
5235   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5236 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5237   cat >conftest.$ac_ext <<_ACEOF
5238 /* confdefs.h.  */
5239 _ACEOF
5240 cat confdefs.h >>conftest.$ac_ext
5241 cat >>conftest.$ac_ext <<_ACEOF
5242 /* end confdefs.h.  */
5243 #include "ppl_c.h"
5244 int
5245 main ()
5246 {
5247
5248   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5249   choke me
5250   #endif
5251
5252   ;
5253   return 0;
5254 }
5255 _ACEOF
5256 rm -f conftest.$ac_objext
5257 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5258   (eval $ac_compile) 2>conftest.er1
5259   ac_status=$?
5260   grep -v '^ *+' conftest.er1 >conftest.err
5261   rm -f conftest.er1
5262   cat conftest.err >&5
5263   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5264   (exit $ac_status); } &&
5265          { ac_try='test -z "$ac_c_werror_flag"
5266                          || test ! -s conftest.err'
5267   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5268   (eval $ac_try) 2>&5
5269   ac_status=$?
5270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5271   (exit $ac_status); }; } &&
5272          { ac_try='test -s conftest.$ac_objext'
5273   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5274   (eval $ac_try) 2>&5
5275   ac_status=$?
5276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5277   (exit $ac_status); }; }; then
5278   echo "$as_me:$LINENO: result: yes" >&5
5279 echo "${ECHO_T}yes" >&6
5280 else
5281   echo "$as_me: failed program was:" >&5
5282 sed 's/^/| /' conftest.$ac_ext >&5
5283
5284 echo "$as_me:$LINENO: result: no" >&5
5285 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5286 fi
5287 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5288   CFLAGS="$saved_CFLAGS"
5289 fi
5290
5291 # Flags needed for PPL
5292
5293
5294
5295
5296 # Check for CLOOG
5297 clooglibs=" -lcloog "
5298 clooginc=" -DCLOOG_PPL_BACKEND "
5299
5300
5301 # Check whether --with-cloog or --without-cloog was given.
5302 if test "${with_cloog+set}" = set; then
5303   withval="$with_cloog"
5304
5305 else
5306   with_cloog=no
5307 fi;
5308
5309 # Check whether --with-cloog_include or --without-cloog_include was given.
5310 if test "${with_cloog_include+set}" = set; then
5311   withval="$with_cloog_include"
5312
5313 fi;
5314
5315 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5316 if test "${with_cloog_lib+set}" = set; then
5317   withval="$with_cloog_lib"
5318
5319 fi;
5320
5321 case $with_cloog in
5322   no)
5323     clooglibs=
5324     clooginc=
5325     ;;
5326   *)
5327     clooglibs="-L$with_cloog/lib -lcloog"
5328     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5329     LIBS="$clooglibs $LIBS"
5330     ;;
5331 esac
5332 if test "x$with_cloog_include" != x; then
5333   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5334 fi
5335 if test "x$with_cloog_lib" != x; then
5336   clooglibs="-L$with_cloog_lib -lcloog"
5337   LIBS="$clooglibs $LIBS"
5338 fi
5339 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5340   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5341   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5342   LIBS="$clooglibs $LIBS"
5343 fi
5344
5345 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5346 if test "${enable_cloog_version_check+set}" = set; then
5347   enableval="$enable_cloog_version_check"
5348   ENABLE_CLOOG_CHECK=$enableval
5349 else
5350   ENABLE_CLOOG_CHECK=yes
5351 fi;
5352
5353 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5354   saved_CFLAGS="$CFLAGS"
5355   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5356   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5357 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5358   cat >conftest.$ac_ext <<_ACEOF
5359 /* confdefs.h.  */
5360 _ACEOF
5361 cat confdefs.h >>conftest.$ac_ext
5362 cat >>conftest.$ac_ext <<_ACEOF
5363 /* end confdefs.h.  */
5364 #include "cloog/cloog.h"
5365 int
5366 main ()
5367 {
5368
5369   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5370   choke me
5371   #endif
5372
5373   ;
5374   return 0;
5375 }
5376 _ACEOF
5377 rm -f conftest.$ac_objext
5378 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5379   (eval $ac_compile) 2>conftest.er1
5380   ac_status=$?
5381   grep -v '^ *+' conftest.er1 >conftest.err
5382   rm -f conftest.er1
5383   cat conftest.err >&5
5384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5385   (exit $ac_status); } &&
5386          { ac_try='test -z "$ac_c_werror_flag"
5387                          || test ! -s conftest.err'
5388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5389   (eval $ac_try) 2>&5
5390   ac_status=$?
5391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5392   (exit $ac_status); }; } &&
5393          { ac_try='test -s conftest.$ac_objext'
5394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5395   (eval $ac_try) 2>&5
5396   ac_status=$?
5397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5398   (exit $ac_status); }; }; then
5399   echo "$as_me:$LINENO: result: yes" >&5
5400 echo "${ECHO_T}yes" >&6
5401 else
5402   echo "$as_me: failed program was:" >&5
5403 sed 's/^/| /' conftest.$ac_ext >&5
5404
5405 echo "$as_me:$LINENO: result: no" >&5
5406 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5407 fi
5408 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5409   CFLAGS="$saved_CFLAGS"
5410 fi
5411
5412 # Flags needed for CLOOG
5413
5414
5415
5416
5417 # By default, C is the only stage 1 language.
5418 stage1_languages=,c,
5419
5420 # Target libraries that we bootstrap.
5421 bootstrap_target_libs=,target-libgcc,
5422
5423 # Figure out what language subdirectories are present.
5424 # Look if the user specified --enable-languages="..."; if not, use
5425 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5426 # go away some day.
5427 # NB:  embedded tabs in this IF block -- do not untabify
5428 if test -d ${srcdir}/gcc; then
5429   if test x"${enable_languages+set}" != xset; then
5430     if test x"${LANGUAGES+set}" = xset; then
5431       enable_languages="${LANGUAGES}"
5432         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5433     else
5434       enable_languages=all
5435     fi
5436   else
5437     if test x"${enable_languages}" = x ||
5438        test x"${enable_languages}" = xyes;
5439        then
5440       echo configure.in: --enable-languages needs at least one language argument 1>&2
5441       exit 1
5442     fi
5443   fi
5444   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5445
5446   # 'f95' is the old name for the 'fortran' language. We issue a warning
5447   # and make the substitution.
5448   case ,${enable_languages}, in
5449     *,f95,*)
5450       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5451       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5452       ;;
5453   esac
5454
5455   # First scan to see if an enabled language requires some other language.
5456   # We assume that a given config-lang.in will list all the language
5457   # front ends it requires, even if some are required indirectly.
5458   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5459     case ${lang_frag} in
5460       ..) ;;
5461       # The odd quoting in the next line works around
5462       # an apparent bug in bash 1.12 on linux.
5463       ${srcdir}/gcc/[*]/config-lang.in) ;;
5464       *)
5465         # From the config-lang.in, get $language, $lang_requires
5466         language=
5467         lang_requires=
5468         . ${lang_frag}
5469         for other in ${lang_requires} ; do
5470           case ,${enable_languages}, in
5471             *,$other,*) ;;
5472             *,all,*) ;;
5473             *,$language,*)
5474               echo " \`$other' language required by \`$language'; enabling" 1>&2
5475               enable_languages="${enable_languages},${other}"
5476               ;;
5477           esac
5478         done
5479         ;;
5480     esac
5481   done
5482
5483   new_enable_languages=,c,
5484   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5485   potential_languages=,c,
5486
5487   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5488     case ${lang_frag} in
5489       ..) ;;
5490       # The odd quoting in the next line works around
5491       # an apparent bug in bash 1.12 on linux.
5492       ${srcdir}/gcc/[*]/config-lang.in) ;;
5493       *)
5494         # From the config-lang.in, get $language, $target_libs,
5495         # $lang_dirs, $boot_language, and $build_by_default
5496         language=
5497         target_libs=
5498         lang_dirs=
5499         subdir_requires=
5500         boot_language=no
5501         build_by_default=yes
5502         . ${lang_frag}
5503         if test x${language} = x; then
5504           echo "${lang_frag} doesn't set \$language." 1>&2
5505           exit 1
5506         fi
5507
5508         if test "$language" = "c++" -a "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5509           boot_language=yes
5510         fi
5511
5512         case ,${enable_languages}, in
5513           *,${language},*)
5514             # Language was explicitly selected; include it.
5515             add_this_lang=yes
5516             ;;
5517           *,all,*)
5518             # 'all' was selected, select it if it is a default language
5519             add_this_lang=${build_by_default}
5520             ;;
5521           *)
5522             add_this_lang=no
5523             ;;
5524         esac
5525
5526         # Disable languages that need other directories if these aren't available.
5527         for i in $subdir_requires; do
5528           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5529           case ,${enable_languages}, in
5530             *,${language},*)
5531               # Specifically requested language; tell them.
5532               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5533 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5534    { (exit 1); exit 1; }; }
5535               ;;
5536             *)
5537               # Silently disable.
5538               add_this_lang=unsupported
5539               ;;
5540           esac
5541         done
5542
5543         # Disable Ada if no preexisting GNAT is available.
5544         case ,${enable_languages},:${language}:${have_gnat} in
5545           *,${language},*:ada:no)
5546             # Specifically requested language; tell them.
5547             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5548 echo "$as_me: error: GNAT is required to build $language" >&2;}
5549    { (exit 1); exit 1; }; }
5550             ;;
5551           *:ada:no)
5552             # Silently disable.
5553             add_this_lang=unsupported
5554             ;;
5555         esac
5556
5557         # Disable a language that is unsupported by the target.
5558         case " $unsupported_languages " in
5559           *" $language "*)
5560             add_this_lang=unsupported
5561             ;;
5562         esac
5563
5564         case $add_this_lang in
5565           unsupported)
5566             # Remove language-dependent dirs.
5567             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5568             ;;
5569           no)
5570             # Remove language-dependent dirs; still show language as supported.
5571             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5572             potential_languages="${potential_languages}${language},"
5573             ;;
5574           yes)
5575             new_enable_languages="${new_enable_languages}${language},"
5576             potential_languages="${potential_languages}${language},"
5577             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5578             case ${boot_language} in
5579               yes)
5580                 # Add to (comma-separated) list of stage 1 languages.
5581                 stage1_languages="${stage1_languages}${language},"
5582                 # We need to bootstrap any supporting libraries.
5583                 bootstrap_target_libs="${bootstrap_target_libs}${target_libs},"
5584                 ;;
5585             esac
5586             ;;
5587         esac
5588         ;;
5589     esac
5590   done
5591
5592   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5593 if test "${enable_stage1_languages+set}" = set; then
5594   enableval="$enable_stage1_languages"
5595   case ,${enable_stage1_languages}, in
5596     ,no,|,,)
5597       # Set it to something that will have no effect in the loop below
5598       enable_stage1_languages=c ;;
5599     ,yes,)
5600       enable_stage1_languages=`echo $new_enable_languages | \
5601         sed -e "s/^,//" -e "s/,$//" ` ;;
5602     *,all,*)
5603       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5604         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5605   esac
5606
5607   # Add "good" languages from enable_stage1_languages to stage1_languages,
5608   # while "bad" languages go in missing_languages.  Leave no duplicates.
5609   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5610     case $potential_languages in
5611       *,$i,*)
5612         case $stage1_languages in
5613           *,$i,*) ;;
5614           *) stage1_languages="$stage1_languages$i," ;;
5615         esac ;;
5616       *)
5617         case $missing_languages in
5618           *,$i,*) ;;
5619           *) missing_languages="$missing_languages$i," ;;
5620         esac ;;
5621      esac
5622   done
5623 fi;
5624
5625   # Remove leading/trailing commas that were added for simplicity
5626   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5627   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5628   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5629   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5630
5631   if test "x$missing_languages" != x; then
5632     { { echo "$as_me:$LINENO: error:
5633 The following requested languages could not be built: ${missing_languages}
5634 Supported languages are: ${potential_languages}" >&5
5635 echo "$as_me: error:
5636 The following requested languages could not be built: ${missing_languages}
5637 Supported languages are: ${potential_languages}" >&2;}
5638    { (exit 1); exit 1; }; }
5639   fi
5640   if test "x$new_enable_languages" != "x$enable_languages"; then
5641     echo The following languages will be built: ${new_enable_languages}
5642     enable_languages="$new_enable_languages"
5643   fi
5644
5645
5646   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5647 fi
5648
5649 # Handle --disable-<component> generically.
5650 for dir in $configdirs $build_configdirs $target_configdirs ; do
5651   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5652   varname=`echo $dirname | sed -e s/+/_/g`
5653   if eval test x\${enable_${varname}} "=" xno ; then
5654     noconfigdirs="$noconfigdirs $dir"
5655   fi
5656 done
5657
5658 # Check for Boehm's garbage collector
5659 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5660 if test "${enable_objc_gc+set}" = set; then
5661   enableval="$enable_objc_gc"
5662   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5663   *,objc,*:*:yes:*target-boehm-gc*)
5664     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5665 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5666    { (exit 1); exit 1; }; }
5667     ;;
5668 esac
5669 fi;
5670
5671 # Make sure we only build Boehm's garbage collector if required.
5672 case ,${enable_languages},:${enable_objc_gc} in
5673   *,objc,*:yes)
5674     # Keep target-boehm-gc if requested for Objective-C.
5675     ;;
5676   *)
5677     # Otherwise remove target-boehm-gc depending on target-libjava.
5678     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5679       noconfigdirs="$noconfigdirs target-boehm-gc"
5680     fi
5681     ;;
5682 esac
5683
5684 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5685 # $build_configdirs and $target_configdirs.
5686 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5687
5688 notsupp=""
5689 for dir in . $skipdirs $noconfigdirs ; do
5690   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5691   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5692     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5693     if test -r $srcdir/$dirname/configure ; then
5694       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5695         true
5696       else
5697         notsupp="$notsupp $dir"
5698       fi
5699     fi
5700   fi
5701   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5702     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5703     if test -r $srcdir/$dirname/configure ; then
5704       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5705         true
5706       else
5707         notsupp="$notsupp $dir"
5708       fi
5709     fi
5710   fi
5711   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5712     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5713     if test -r $srcdir/$dirname/configure ; then
5714       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5715         true
5716       else
5717         notsupp="$notsupp $dir"
5718       fi
5719     fi
5720   fi
5721 done
5722
5723 # Sometimes the tools are distributed with libiberty but with no other
5724 # libraries.  In that case, we don't want to build target-libiberty.
5725 # Don't let libgcc imply libiberty either.
5726 if test -n "${target_configdirs}" ; then
5727   libgcc=
5728   others=
5729   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5730     if test "$i" = "libgcc"; then
5731       libgcc=target-libgcc
5732     elif test "$i" != "libiberty" ; then
5733       if test -r $srcdir/$i/configure ; then
5734         others=yes;
5735         break;
5736       fi
5737     fi
5738   done
5739   if test -z "${others}" ; then
5740     target_configdirs=$libgcc
5741   fi
5742 fi
5743
5744 # Quietly strip out all directories which aren't configurable in this tree.
5745 # This relies on all configurable subdirectories being autoconfiscated, which
5746 # is now the case.
5747 build_configdirs_all="$build_configdirs"
5748 build_configdirs=
5749 for i in ${build_configdirs_all} ; do
5750   j=`echo $i | sed -e s/build-//g`
5751   if test -f ${srcdir}/$j/configure ; then
5752     build_configdirs="${build_configdirs} $i"
5753   fi
5754 done
5755
5756 configdirs_all="$configdirs"
5757 configdirs=
5758 for i in ${configdirs_all} ; do
5759   if test -f ${srcdir}/$i/configure ; then
5760     configdirs="${configdirs} $i"
5761   fi
5762 done
5763
5764 target_configdirs_all="$target_configdirs"
5765 target_configdirs=
5766 for i in ${target_configdirs_all} ; do
5767   j=`echo $i | sed -e s/target-//g`
5768   if test -f ${srcdir}/$j/configure ; then
5769     target_configdirs="${target_configdirs} $i"
5770   fi
5771 done
5772
5773 # Produce a warning message for the subdirs we can't configure.
5774 # This isn't especially interesting in the Cygnus tree, but in the individual
5775 # FSF releases, it's important to let people know when their machine isn't
5776 # supported by the one or two programs in a package.
5777
5778 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5779   # If $appdirs is non-empty, at least one of those directories must still
5780   # be configured, or we error out.  (E.g., if the gas release supports a
5781   # specified target in some subdirs but not the gas subdir, we shouldn't
5782   # pretend that all is well.)
5783   if test -n "$appdirs" ; then
5784     for dir in $appdirs ; do
5785       if test -r $dir/Makefile.in ; then
5786         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5787           appdirs=""
5788           break
5789         fi
5790         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5791           appdirs=""
5792           break
5793         fi
5794       fi
5795     done
5796     if test -n "$appdirs" ; then
5797       echo "*** This configuration is not supported by this package." 1>&2
5798       exit 1
5799     fi
5800   fi
5801   # Okay, some application will build, or we don't care to check.  Still
5802   # notify of subdirs not getting built.
5803   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5804   echo "    ${notsupp}" 1>&2
5805   echo "    (Any other directories should still work fine.)" 1>&2
5806 fi
5807
5808 case "$host" in
5809   *msdosdjgpp*)
5810     enable_gdbtk=no ;;
5811 esac
5812
5813 # To find our prefix, in gcc_cv_tool_prefix.
5814
5815 # The user is always right.
5816 if test "${PATH_SEPARATOR+set}" != set; then
5817   echo "#! /bin/sh" >conf$$.sh
5818   echo  "exit 0"   >>conf$$.sh
5819   chmod +x conf$$.sh
5820   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5821     PATH_SEPARATOR=';'
5822   else
5823     PATH_SEPARATOR=:
5824   fi
5825   rm -f conf$$.sh
5826 fi
5827
5828
5829
5830 if test "x$exec_prefix" = xNONE; then
5831         if test "x$prefix" = xNONE; then
5832                 gcc_cv_tool_prefix=$ac_default_prefix
5833         else
5834                 gcc_cv_tool_prefix=$prefix
5835         fi
5836 else
5837         gcc_cv_tool_prefix=$exec_prefix
5838 fi
5839
5840 # If there is no compiler in the tree, use the PATH only.  In any
5841 # case, if there is no compiler in the tree nobody should use
5842 # AS_FOR_TARGET and LD_FOR_TARGET.
5843 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5844     gcc_version=`cat $srcdir/gcc/BASE-VER`
5845     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5846     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5847     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5848     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5849     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5850     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5851 else
5852     gcc_cv_tool_dirs=
5853 fi
5854
5855 if test x$build = x$target && test -n "$md_exec_prefix"; then
5856         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5857 fi
5858
5859
5860
5861 copy_dirs=
5862
5863
5864 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5865 if test "${with_build_sysroot+set}" = set; then
5866   withval="$with_build_sysroot"
5867   if test x"$withval" != x ; then
5868      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5869    fi
5870 else
5871   SYSROOT_CFLAGS_FOR_TARGET=
5872 fi;
5873
5874
5875
5876 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5877 if test "${with_debug_prefix_map+set}" = set; then
5878   withval="$with_debug_prefix_map"
5879   if test x"$withval" != x; then
5880      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5881      for debug_map in $withval; do
5882        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5883      done
5884    fi
5885 else
5886   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5887 fi;
5888
5889
5890 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5891 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5892 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5893 # We want to ensure that TARGET libraries (which we know are built with
5894 # gcc) are built with "-O2 -g", so include those options when setting
5895 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5896 if test "x$CFLAGS_FOR_TARGET" = x; then
5897   CFLAGS_FOR_TARGET=$CFLAGS
5898   case " $CFLAGS " in
5899     *" -O2 "*) ;;
5900     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5901   esac
5902   case " $CFLAGS " in
5903     *" -g "* | *" -g3 "*) ;;
5904     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5905   esac
5906 fi
5907
5908
5909 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5910   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5911   case " $CXXFLAGS " in
5912     *" -O2 "*) ;;
5913     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5914   esac
5915   case " $CXXFLAGS " in
5916     *" -g "* | *" -g3 "*) ;;
5917     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5918   esac
5919 fi
5920
5921
5922 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5923 # the named directory are copied to $(tooldir)/sys-include.
5924 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5925   if test x${is_cross_compiler} = xno ; then
5926     echo 1>&2 '***' --with-headers is only supported when cross compiling
5927     exit 1
5928   fi
5929   if test x"${with_headers}" != xyes ; then
5930     x=${gcc_cv_tool_prefix}
5931     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5932   fi
5933 fi
5934
5935 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5936 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5937 # are permitted.
5938 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5939   if test x${is_cross_compiler} = xno ; then
5940     echo 1>&2 '***' --with-libs is only supported when cross compiling
5941     exit 1
5942   fi
5943   if test x"${with_libs}" != xyes ; then
5944     # Copy the libraries in reverse order, so that files in the first named
5945     # library override files in subsequent libraries.
5946     x=${gcc_cv_tool_prefix}
5947     for l in ${with_libs}; do
5948       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5949     done
5950   fi
5951 fi
5952
5953 # Set with_gnu_as and with_gnu_ld as appropriate.
5954 #
5955 # This is done by determining whether or not the appropriate directory
5956 # is available, and by checking whether or not specific configurations
5957 # have requested that this magic not happen.
5958 #
5959 # The command line options always override the explicit settings in
5960 # configure.in, and the settings in configure.in override this magic.
5961 #
5962 # If the default for a toolchain is to use GNU as and ld, and you don't
5963 # want to do that, then you should use the --without-gnu-as and
5964 # --without-gnu-ld options for the configure script.
5965
5966 if test x${use_gnu_as} = x &&
5967    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5968   with_gnu_as=yes
5969   extra_host_args="$extra_host_args --with-gnu-as"
5970 fi
5971
5972 if test x${use_gnu_ld} = x &&
5973    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5974   with_gnu_ld=yes
5975   extra_host_args="$extra_host_args --with-gnu-ld"
5976 fi
5977
5978 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5979 # can detect this case.
5980
5981 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5982   with_newlib=yes
5983   extra_host_args="$extra_host_args --with-newlib"
5984 fi
5985
5986 # Handle ${copy_dirs}
5987 set fnord ${copy_dirs}
5988 shift
5989 while test $# != 0 ; do
5990   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5991     :
5992   else
5993     echo Copying $1 to $2
5994
5995     # Use the install script to create the directory and all required
5996     # parent directories.
5997     if test -d $2 ; then
5998       :
5999     else
6000       echo >config.temp
6001       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
6002     fi
6003
6004     # Copy the directory, assuming we have tar.
6005     # FIXME: Should we use B in the second tar?  Not all systems support it.
6006     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
6007
6008     # It is the responsibility of the user to correctly adjust all
6009     # symlinks.  If somebody can figure out how to handle them correctly
6010     # here, feel free to add the code.
6011
6012     echo $1 > $2/COPIED
6013   fi
6014   shift; shift
6015 done
6016
6017 # Determine a target-dependent exec_prefix that the installed
6018 # gcc will search in.  Keep this list sorted by triplet, with
6019 # the *-*-osname triplets last.
6020 md_exec_prefix=
6021 case "${target}" in
6022   alpha*-*-*vms*)
6023     md_exec_prefix=/gnu/lib/gcc-lib
6024     ;;
6025   i[34567]86-pc-msdosdjgpp*)
6026     md_exec_prefix=/dev/env/DJDIR/bin
6027     ;;
6028   i[34567]86-*-sco3.2v5*)
6029     if test $with_gnu_as = yes; then
6030       md_exec_prefix=/usr/gnu/bin
6031     else
6032       md_exec_prefix=/usr/ccs/bin/elf
6033     fi
6034     ;;
6035
6036   mn10300-*-* | \
6037   powerpc-*-chorusos* | \
6038   powerpc*-*-eabi* | \
6039   powerpc*-*-sysv* | \
6040   powerpc*-*-kaos* | \
6041   s390x-ibm-tpf*)
6042     md_exec_prefix=/usr/ccs/bin
6043     ;;
6044   sparc64-*-elf*)
6045     ;;
6046   v850*-*-*)
6047     md_exec_prefix=/usr/ccs/bin
6048     ;;
6049   xtensa*-*-elf*)
6050     ;;
6051
6052   *-*-beos* | \
6053   *-*-elf* | \
6054   *-*-hpux* | \
6055   *-*-netware* | \
6056   *-*-nto-qnx* | \
6057   *-*-rtems* | \
6058   *-*-solaris2* | \
6059   *-*-sysv[45]* | \
6060   *-*-vxworks* | \
6061   *-wrs-windiss)
6062     md_exec_prefix=/usr/ccs/bin
6063     ;;
6064 esac
6065
6066 extra_arflags_for_target=
6067 extra_nmflags_for_target=
6068 extra_ranlibflags_for_target=
6069 target_makefile_frag=/dev/null
6070 case "${target}" in
6071   mep*-*-*)
6072     target_makefile_frag="config/mt-mep"
6073     ;;
6074   spu-*-*)
6075     target_makefile_frag="config/mt-spu"
6076     ;;
6077   mips*-sde-elf*)
6078     target_makefile_frag="config/mt-sde"
6079     ;;
6080   mipsisa*-*-elfoabi*)
6081     target_makefile_frag="config/mt-mips-elfoabi"
6082     ;;
6083   mips*-*-*linux* | mips*-*-gnu*)
6084     target_makefile_frag="config/mt-mips-gnu"
6085     ;;
6086   *-*-netware*)
6087     target_makefile_frag="config/mt-netware"
6088     ;;
6089   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
6090     target_makefile_frag="config/mt-gnu"
6091     ;;
6092   *-*-aix4.[3456789]* | *-*-aix[56789].*)
6093     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
6094     # commands to handle both 32-bit and 64-bit objects.  These flags are
6095     # harmless if we're using GNU nm or ar.
6096     extra_arflags_for_target=" -X32_64"
6097     extra_nmflags_for_target=" -B -X32_64"
6098     ;;
6099   *-*-darwin*)
6100     # ranlib from Darwin requires the -c flag to look at common symbols.
6101     extra_ranlibflags_for_target=" -c"
6102     ;;
6103   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6104     target_makefile_frag="config/mt-wince"
6105     ;;
6106 esac
6107
6108 alphaieee_frag=/dev/null
6109 case $target in
6110   alpha*-*-*)
6111     # This just makes sure to use the -mieee option to build target libs.
6112     # This should probably be set individually by each library.
6113     alphaieee_frag="config/mt-alphaieee"
6114     ;;
6115 esac
6116
6117 # If --enable-target-optspace always use -Os instead of -O2 to build
6118 # the target libraries, similarly if it is not specified, use -Os
6119 # on selected platforms.
6120 ospace_frag=/dev/null
6121 case "${enable_target_optspace}:${target}" in
6122   yes:*)
6123     ospace_frag="config/mt-ospace"
6124     ;;
6125   :d30v-*)
6126     ospace_frag="config/mt-d30v"
6127     ;;
6128   :m32r-* | :d10v-* | :fr30-*)
6129     ospace_frag="config/mt-ospace"
6130     ;;
6131   no:* | :*)
6132     ;;
6133   *)
6134     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6135     ;;
6136 esac
6137
6138 # Default to using --with-stabs for certain targets.
6139 if test x${with_stabs} = x ; then
6140   case "${target}" in
6141   mips*-*-irix[56]*)
6142     ;;
6143   mips*-*-* | alpha*-*-osf*)
6144     with_stabs=yes;
6145     extra_host_args="${extra_host_args} --with-stabs"
6146     ;;
6147   esac
6148 fi
6149
6150 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6151 # them automatically.
6152 case "${host}" in
6153   hppa*64*-*-hpux11*)
6154     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6155     ;;
6156 esac
6157
6158 # Some systems (e.g., one of the i386-aix systems the gas testers are
6159 # using) don't handle "\$" correctly, so don't use it here.
6160 tooldir='${exec_prefix}'/${target_noncanonical}
6161 build_tooldir=${tooldir}
6162
6163 # Create a .gdbinit file which runs the one in srcdir
6164 # and tells GDB to look there for source files.
6165
6166 if test -r ${srcdir}/.gdbinit ; then
6167   case ${srcdir} in
6168     .) ;;
6169     *) cat > ./.gdbinit <<EOF
6170 # ${NO_EDIT}
6171 dir ${srcdir}
6172 dir .
6173 source ${srcdir}/.gdbinit
6174 EOF
6175     ;;
6176   esac
6177 fi
6178
6179 # Make sure that the compiler is able to generate an executable.  If it
6180 # can't, we are probably in trouble.  We don't care whether we can run the
6181 # executable--we might be using a cross compiler--we only care whether it
6182 # can be created.  At this point the main configure script has set CC.
6183 we_are_ok=no
6184 echo "int main () { return 0; }" > conftest.c
6185 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6186 if test $? = 0 ; then
6187   if test -s conftest || test -s conftest.exe ; then
6188     we_are_ok=yes
6189   fi
6190 fi
6191 case $we_are_ok in
6192   no)
6193     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6194     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6195     rm -f conftest*
6196     exit 1
6197     ;;
6198 esac
6199 rm -f conftest*
6200
6201 # The Solaris /usr/ucb/cc compiler does not appear to work.
6202 case "${host}" in
6203   sparc-sun-solaris2*)
6204       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6205       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6206           could_use=
6207           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6208           if test -d /opt/cygnus/bin ; then
6209               if test "$could_use" = "" ; then
6210                   could_use="/opt/cygnus/bin"
6211               else
6212                   could_use="$could_use or /opt/cygnus/bin"
6213               fi
6214           fi
6215         if test "$could_use" = "" ; then
6216             echo "Warning: compilation may fail because you're using"
6217             echo "/usr/ucb/cc.  You should change your PATH or CC "
6218             echo "variable and rerun configure."
6219         else
6220             echo "Warning: compilation may fail because you're using"
6221             echo "/usr/ucb/cc, when you should use the C compiler from"
6222             echo "$could_use.  You should change your"
6223             echo "PATH or CC variable and rerun configure."
6224         fi
6225       fi
6226   ;;
6227 esac
6228
6229 # Decide which environment variable is used to find dynamic libraries.
6230 case "${host}" in
6231   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6232   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6233   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6234   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6235 esac
6236
6237 # On systems where the dynamic library environment variable is PATH,
6238 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6239 # built executables to PATH.
6240 if test "$RPATH_ENVVAR" = PATH; then
6241   GCC_SHLIB_SUBDIR=/shlib
6242 else
6243   GCC_SHLIB_SUBDIR=
6244 fi
6245
6246 # Record target_configdirs and the configure arguments for target and
6247 # build configuration in Makefile.
6248 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6249 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6250
6251 # Determine whether gdb needs tk/tcl or not.
6252 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6253 # and in that case we want gdb to be built without tk.  Ugh!
6254 # In fact I believe gdb is the *only* package directly dependent on tk,
6255 # so we should be able to put the 'maybe's in unconditionally and
6256 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6257 # 100% sure that that's safe though.
6258
6259 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6260 case "$enable_gdbtk" in
6261   no)
6262     GDB_TK="" ;;
6263   yes)
6264     GDB_TK="${gdb_tk}" ;;
6265   *)
6266     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6267     # distro.  Eventually someone will fix this and move Insight, nee
6268     # gdbtk to a separate directory.
6269     if test -d ${srcdir}/gdb/gdbtk ; then
6270       GDB_TK="${gdb_tk}"
6271     else
6272       GDB_TK=""
6273     fi
6274     ;;
6275 esac
6276 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6277 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6278
6279 # Strip out unwanted targets.
6280
6281 # While at that, we remove Makefiles if we were started for recursive
6282 # configuration, so that the top-level Makefile reconfigures them,
6283 # like we used to do when configure itself was recursive.
6284
6285 # Loop over modules.  $extrasub must be used with care, limiting as
6286 # much as possible the usage of range addresses.  That's because autoconf
6287 # splits the sed script to overcome limits in the number of commands,
6288 # and relying on carefully-timed sed passes may turn out to be very hard
6289 # to maintain later.  In this particular case, you just have to be careful
6290 # not to nest @if/@endif pairs, because configure will not warn you at all.
6291
6292 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6293 if test "${enable_bootstrap+set}" = set; then
6294   enableval="$enable_bootstrap"
6295
6296 else
6297   enable_bootstrap=default
6298 fi;
6299
6300 # Issue errors and warnings for invalid/strange bootstrap combinations.
6301 case "$configdirs" in
6302   *gcc*) have_compiler=yes ;;
6303   *) have_compiler=no ;;
6304 esac
6305
6306 case "$have_compiler:$host:$target:$enable_bootstrap" in
6307   *:*:*:no) ;;
6308
6309   # Default behavior.  Enable bootstrap if we have a compiler
6310   # and we are in a native configuration.
6311   yes:$build:$build:default)
6312     enable_bootstrap=yes ;;
6313
6314   *:*:*:default)
6315     enable_bootstrap=no ;;
6316
6317   # We have a compiler and we are in a native configuration, bootstrap is ok
6318   yes:$build:$build:yes)
6319     ;;
6320
6321   # Other configurations, but we have a compiler.  Assume the user knows
6322   # what he's doing.
6323   yes:*:*:yes)
6324     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6325 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6326     ;;
6327
6328   # No compiler: if they passed --enable-bootstrap explicitly, fail
6329   no:*:*:yes)
6330     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6331 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6332    { (exit 1); exit 1; }; } ;;
6333
6334   # Fail if wrong command line
6335   *)
6336     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6337 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6338    { (exit 1); exit 1; }; }
6339     ;;
6340 esac
6341
6342 # Adjust the toplevel makefile according to whether bootstrap was selected.
6343 case "$enable_bootstrap" in
6344   yes)
6345     bootstrap_suffix=bootstrap ;;
6346   no)
6347     bootstrap_suffix=no-bootstrap ;;
6348 esac
6349
6350 for module in ${build_configdirs} ; do
6351   if test -z "${no_recursion}" \
6352      && test -f ${build_subdir}/${module}/Makefile; then
6353     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6354     rm -f ${build_subdir}/${module}/Makefile
6355   fi
6356   extrasub="$extrasub
6357 /^@if build-$module\$/d
6358 /^@endif build-$module\$/d
6359 /^@if build-$module-$bootstrap_suffix\$/d
6360 /^@endif build-$module-$bootstrap_suffix\$/d"
6361 done
6362 for module in ${configdirs} ; do
6363   if test -z "${no_recursion}"; then
6364     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6365       if test -f ${file}; then
6366         echo 1>&2 "*** removing ${file} to force reconfigure"
6367         rm -f ${file}
6368       fi
6369     done
6370   fi
6371   extrasub="$extrasub
6372 /^@if $module\$/d
6373 /^@endif $module\$/d
6374 /^@if $module-$bootstrap_suffix\$/d
6375 /^@endif $module-$bootstrap_suffix\$/d"
6376 done
6377 for module in ${target_configdirs} ; do
6378   if test -z "${no_recursion}" \
6379      && test -f ${target_subdir}/${module}/Makefile; then
6380     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6381     rm -f ${target_subdir}/${module}/Makefile
6382   fi
6383
6384   # We only bootstrap target libraries listed in bootstrap_target_libs.
6385   case $bootstrap_target_libs in
6386     *,target-$module,*) target_bootstrap_suffix=$bootstrap_suffix ;;
6387     *) target_bootstrap_suffix=no-bootstrap ;;
6388   esac
6389
6390   extrasub="$extrasub
6391 /^@if target-$module\$/d
6392 /^@endif target-$module\$/d
6393 /^@if target-$module-$target_bootstrap_suffix\$/d
6394 /^@endif target-$module-$target_bootstrap_suffix\$/d"
6395 done
6396
6397 extrasub="$extrasub
6398 /^@if /,/^@endif /d"
6399
6400 # Create the serialization dependencies.  This uses a temporary file.
6401
6402 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6403 if test "${enable_serial_configure+set}" = set; then
6404   enableval="$enable_serial_configure"
6405
6406 fi;
6407
6408 case ${enable_serial_configure} in
6409   yes)
6410     enable_serial_build_configure=yes
6411     enable_serial_host_configure=yes
6412     enable_serial_target_configure=yes
6413     ;;
6414 esac
6415
6416 # These force 'configure's to be done one at a time, to avoid problems
6417 # with contention over a shared config.cache.
6418 rm -f serdep.tmp
6419 echo '# serdep.tmp' > serdep.tmp
6420 olditem=
6421 test "x${enable_serial_build_configure}" = xyes &&
6422 for item in ${build_configdirs} ; do
6423   case ${olditem} in
6424     "") ;;
6425     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6426   esac
6427   olditem=${item}
6428 done
6429 olditem=
6430 test "x${enable_serial_host_configure}" = xyes &&
6431 for item in ${configdirs} ; do
6432   case ${olditem} in
6433     "") ;;
6434     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6435   esac
6436   olditem=${item}
6437 done
6438 olditem=
6439 test "x${enable_serial_target_configure}" = xyes &&
6440 for item in ${target_configdirs} ; do
6441   case ${olditem} in
6442     "") ;;
6443     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6444   esac
6445   olditem=${item}
6446 done
6447 serialization_dependencies=serdep.tmp
6448
6449
6450 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6451 # target, nonopt, and variable assignments.  These are the ones we
6452 # might not want to pass down to subconfigures.  Also strip
6453 # program-prefix, program-suffix, and program-transform-name, so that
6454 # we can pass down a consistent program-transform-name.
6455 baseargs=
6456 keep_next=no
6457 skip_next=no
6458 eval "set -- $ac_configure_args"
6459 for ac_arg
6460 do
6461   if test X"$skip_next" = X"yes"; then
6462     skip_next=no
6463     continue
6464   fi
6465   if test X"$keep_next" = X"yes"; then
6466     case $ac_arg in
6467       *\'*)
6468         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6469     esac
6470     baseargs="$baseargs '$ac_arg'"
6471     keep_next=no
6472     continue
6473   fi
6474
6475   # Handle separated arguments.  Based on the logic generated by
6476   # autoconf 2.59.
6477   case $ac_arg in
6478     *=* | --config-cache | -C | -disable-* | --disable-* \
6479       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6480       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6481       | -with-* | --with-* | -without-* | --without-* | --x)
6482       separate_arg=no
6483       ;;
6484     -*)
6485       separate_arg=yes
6486       ;;
6487     *)
6488       separate_arg=no
6489       ;;
6490   esac
6491
6492   case "$ac_arg" in
6493     --no*)
6494       continue
6495       ;;
6496     --c* | \
6497     --sr* | \
6498     --ho* | \
6499     --bu* | \
6500     --t* | \
6501     --program-* | \
6502     -cache_file* | \
6503     -srcdir* | \
6504     -host* | \
6505     -build* | \
6506     -target* | \
6507     -program-prefix* | \
6508     -program-suffix* | \
6509     -program-transform-name* )
6510       skip_next=$separate_arg
6511       continue
6512       ;;
6513     -*)
6514       # An option.  Add it.
6515       case $ac_arg in
6516         *\'*)
6517           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6518       esac
6519       baseargs="$baseargs '$ac_arg'"
6520       keep_next=$separate_arg
6521       ;;
6522     *)
6523       # Either a variable assignment, or a nonopt (triplet).  Don't
6524       # pass it down; let the Makefile handle this.
6525       continue
6526       ;;
6527   esac
6528 done
6529 # Remove the initial space we just introduced and, as these will be
6530 # expanded by make, quote '$'.
6531 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6532
6533 # Add in --program-transform-name, after --program-prefix and
6534 # --program-suffix have been applied to it.  Autoconf has already
6535 # doubled dollar signs and backslashes in program_transform_name; we want
6536 # the backslashes un-doubled, and then the entire thing wrapped in single
6537 # quotes, because this will be expanded first by make and then by the shell.
6538 # Also, because we want to override the logic in subdir configure scripts to
6539 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6540 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6541 ${program_transform_name}
6542 EOF_SED
6543 gcc_transform_name=`cat conftestsed.out`
6544 rm -f conftestsed.out
6545 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6546 if test "$silent" = yes; then
6547   baseargs="$baseargs --silent"
6548 fi
6549
6550 # For the build-side libraries, we just need to pretend we're native,
6551 # and not use the same cache file.  Multilibs are neither needed nor
6552 # desired.
6553 build_configargs="--cache-file=../config.cache ${baseargs}"
6554
6555 # For host modules, accept cache file option, or specification as blank.
6556 case "${cache_file}" in
6557 "") # empty
6558   cache_file_option="" ;;
6559 /* | [A-Za-z]:[\\/]* ) # absolute path
6560   cache_file_option="--cache-file=${cache_file}" ;;
6561 *) # relative path
6562   cache_file_option="--cache-file=../${cache_file}" ;;
6563 esac
6564
6565 # Host dirs don't like to share a cache file either, horribly enough.
6566 # This seems to be due to autoconf 2.5x stupidity.
6567 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6568
6569 target_configargs=${baseargs}
6570
6571 # Passing a --with-cross-host argument lets the target libraries know
6572 # whether they are being built with a cross-compiler or being built
6573 # native.  However, it would be better to use other mechanisms to make the
6574 # sorts of decisions they want to make on this basis.  Please consider
6575 # this option to be deprecated.  FIXME.
6576 if test x${is_cross_compiler} = xyes ; then
6577   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6578 fi
6579
6580 # Default to --enable-multilib.
6581 if test x${enable_multilib} = x ; then
6582   target_configargs="--enable-multilib ${target_configargs}"
6583 fi
6584
6585 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6586 # changed from the earlier setting of with_newlib.
6587 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6588   target_configargs="--with-newlib ${target_configargs}"
6589 fi
6590
6591 # Different target subdirs use different values of certain variables
6592 # (notably CXX).  Worse, multilibs use *lots* of different values.
6593 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6594 # it doesn't automatically accept command-line overrides of them.
6595 # This means it's not safe for target subdirs to share a cache file,
6596 # which is disgusting, but there you have it.  Hopefully this can be
6597 # fixed in future.  It's still worthwhile to use a cache file for each
6598 # directory.  I think.
6599
6600 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6601 # We need to pass --target, as newer autoconf's requires consistency
6602 # for target_alias and gcc doesn't manage it consistently.
6603 target_configargs="--cache-file=./config.cache ${target_configargs}"
6604
6605 FLAGS_FOR_TARGET=
6606 case " $target_configdirs " in
6607  *" newlib "*)
6608   case " $target_configargs " in
6609   *" --with-newlib "*)
6610    case "$target" in
6611    *-cygwin*)
6612      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' ;;
6613    esac
6614
6615    # If we're not building GCC, don't discard standard headers.
6616    if test -d ${srcdir}/gcc; then
6617      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6618
6619      if test "${build}" != "${host}"; then
6620        # On Canadian crosses, CC_FOR_TARGET will have already been set
6621        # by `configure', so we won't have an opportunity to add -Bgcc/
6622        # to it.  This is right: we don't want to search that directory
6623        # for binaries, but we want the header files in there, so add
6624        # them explicitly.
6625        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6626
6627        # Someone might think of using the pre-installed headers on
6628        # Canadian crosses, in case the installed compiler is not fully
6629        # compatible with the compiler being built.  In this case, it
6630        # would be better to flag an error than risking having
6631        # incompatible object files being constructed.  We can't
6632        # guarantee that an error will be flagged, but let's hope the
6633        # compiler will do it, when presented with incompatible header
6634        # files.
6635      fi
6636    fi
6637
6638    case "${target}-${is_cross_compiler}" in
6639    i[3456789]86-*-linux*-no)
6640       # Here host == target, so we don't need to build gcc,
6641       # so we don't want to discard standard headers.
6642       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6643       ;;
6644    *)
6645       # If we're building newlib, use its generic headers last, but search
6646       # for any libc-related directories first (so make it the last -B
6647       # switch).
6648       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6649
6650       # If we're building libgloss, find the startup file, simulator library
6651       # and linker script.
6652       case " $target_configdirs " in
6653         *" libgloss "*)
6654         # Look for startup file, simulator library and maybe linker script.
6655         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6656         # Look for libnosys.a in case the target needs it.
6657         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6658         # Most targets have the linker script in the source directory.
6659         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6660         ;;
6661       esac
6662       ;;
6663    esac
6664    ;;
6665   esac
6666   ;;
6667 esac
6668 case "$target" in
6669 *-mingw*)
6670   # Can't be handled as Cygwin above since Mingw does not use newlib.
6671   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' ;;
6672 esac
6673
6674 # Allow the user to override the flags for
6675 # our build compiler if desired.
6676 if test x"${build}" = x"${host}" ; then
6677   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6678   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6679   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6680 fi
6681
6682 # On Canadian crosses, we'll be searching the right directories for
6683 # the previously-installed cross compiler, so don't bother to add
6684 # flags for directories within the install tree of the compiler
6685 # being built; programs in there won't even run.
6686 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6687   # Search for pre-installed headers if nothing else fits.
6688   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6689 fi
6690
6691 if test "x${use_gnu_ld}" = x &&
6692    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6693   # Arrange for us to find uninstalled linker scripts.
6694   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6695 fi
6696
6697 # Search for other target-specific linker scripts and such.
6698 case "${target}" in
6699   mep*)
6700     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6701     ;;
6702 esac
6703
6704 # Makefile fragments.
6705 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6706 do
6707   eval fragval=\$$frag
6708   if test $fragval != /dev/null; then
6709     eval $frag=${srcdir}/$fragval
6710   fi
6711 done
6712
6713
6714
6715
6716
6717 # Miscellanea: directories, flags, etc.
6718
6719
6720
6721
6722
6723
6724
6725
6726 # Build module lists & subconfigure args.
6727
6728
6729
6730 # Host module lists & subconfigure args.
6731
6732
6733
6734 # Target module lists & subconfigure args.
6735
6736
6737
6738 # Build tools.
6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752
6753
6754
6755
6756 # Generate default definitions for YACC, M4, LEX and other programs that run
6757 # on the build machine.  These are used if the Makefile can't locate these
6758 # programs in objdir.
6759 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6760
6761 for ac_prog in 'bison -y' byacc yacc
6762 do
6763   # Extract the first word of "$ac_prog", so it can be a program name with args.
6764 set dummy $ac_prog; ac_word=$2
6765 echo "$as_me:$LINENO: checking for $ac_word" >&5
6766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6767 if test "${ac_cv_prog_YACC+set}" = set; then
6768   echo $ECHO_N "(cached) $ECHO_C" >&6
6769 else
6770   if test -n "$YACC"; then
6771   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6772 else
6773 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6774 for as_dir in $PATH
6775 do
6776   IFS=$as_save_IFS
6777   test -z "$as_dir" && as_dir=.
6778   for ac_exec_ext in '' $ac_executable_extensions; do
6779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6780     ac_cv_prog_YACC="$ac_prog"
6781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6782     break 2
6783   fi
6784 done
6785 done
6786
6787 fi
6788 fi
6789 YACC=$ac_cv_prog_YACC
6790 if test -n "$YACC"; then
6791   echo "$as_me:$LINENO: result: $YACC" >&5
6792 echo "${ECHO_T}$YACC" >&6
6793 else
6794   echo "$as_me:$LINENO: result: no" >&5
6795 echo "${ECHO_T}no" >&6
6796 fi
6797
6798   test -n "$YACC" && break
6799 done
6800 test -n "$YACC" || YACC="$MISSING bison -y"
6801
6802 case " $build_configdirs " in
6803   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6804   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6805 esac
6806
6807 for ac_prog in bison
6808 do
6809   # Extract the first word of "$ac_prog", so it can be a program name with args.
6810 set dummy $ac_prog; ac_word=$2
6811 echo "$as_me:$LINENO: checking for $ac_word" >&5
6812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6813 if test "${ac_cv_prog_BISON+set}" = set; then
6814   echo $ECHO_N "(cached) $ECHO_C" >&6
6815 else
6816   if test -n "$BISON"; then
6817   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6818 else
6819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6820 for as_dir in $PATH
6821 do
6822   IFS=$as_save_IFS
6823   test -z "$as_dir" && as_dir=.
6824   for ac_exec_ext in '' $ac_executable_extensions; do
6825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6826     ac_cv_prog_BISON="$ac_prog"
6827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6828     break 2
6829   fi
6830 done
6831 done
6832
6833 fi
6834 fi
6835 BISON=$ac_cv_prog_BISON
6836 if test -n "$BISON"; then
6837   echo "$as_me:$LINENO: result: $BISON" >&5
6838 echo "${ECHO_T}$BISON" >&6
6839 else
6840   echo "$as_me:$LINENO: result: no" >&5
6841 echo "${ECHO_T}no" >&6
6842 fi
6843
6844   test -n "$BISON" && break
6845 done
6846 test -n "$BISON" || BISON="$MISSING bison"
6847
6848 case " $build_configdirs " in
6849   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6850 esac
6851
6852 for ac_prog in gm4 gnum4 m4
6853 do
6854   # Extract the first word of "$ac_prog", so it can be a program name with args.
6855 set dummy $ac_prog; ac_word=$2
6856 echo "$as_me:$LINENO: checking for $ac_word" >&5
6857 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6858 if test "${ac_cv_prog_M4+set}" = set; then
6859   echo $ECHO_N "(cached) $ECHO_C" >&6
6860 else
6861   if test -n "$M4"; then
6862   ac_cv_prog_M4="$M4" # Let the user override the test.
6863 else
6864 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6865 for as_dir in $PATH
6866 do
6867   IFS=$as_save_IFS
6868   test -z "$as_dir" && as_dir=.
6869   for ac_exec_ext in '' $ac_executable_extensions; do
6870   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6871     ac_cv_prog_M4="$ac_prog"
6872     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6873     break 2
6874   fi
6875 done
6876 done
6877
6878 fi
6879 fi
6880 M4=$ac_cv_prog_M4
6881 if test -n "$M4"; then
6882   echo "$as_me:$LINENO: result: $M4" >&5
6883 echo "${ECHO_T}$M4" >&6
6884 else
6885   echo "$as_me:$LINENO: result: no" >&5
6886 echo "${ECHO_T}no" >&6
6887 fi
6888
6889   test -n "$M4" && break
6890 done
6891 test -n "$M4" || M4="$MISSING m4"
6892
6893 case " $build_configdirs " in
6894   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6895 esac
6896
6897 for ac_prog in flex lex
6898 do
6899   # Extract the first word of "$ac_prog", so it can be a program name with args.
6900 set dummy $ac_prog; ac_word=$2
6901 echo "$as_me:$LINENO: checking for $ac_word" >&5
6902 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6903 if test "${ac_cv_prog_LEX+set}" = set; then
6904   echo $ECHO_N "(cached) $ECHO_C" >&6
6905 else
6906   if test -n "$LEX"; then
6907   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6908 else
6909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6910 for as_dir in $PATH
6911 do
6912   IFS=$as_save_IFS
6913   test -z "$as_dir" && as_dir=.
6914   for ac_exec_ext in '' $ac_executable_extensions; do
6915   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6916     ac_cv_prog_LEX="$ac_prog"
6917     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6918     break 2
6919   fi
6920 done
6921 done
6922
6923 fi
6924 fi
6925 LEX=$ac_cv_prog_LEX
6926 if test -n "$LEX"; then
6927   echo "$as_me:$LINENO: result: $LEX" >&5
6928 echo "${ECHO_T}$LEX" >&6
6929 else
6930   echo "$as_me:$LINENO: result: no" >&5
6931 echo "${ECHO_T}no" >&6
6932 fi
6933
6934   test -n "$LEX" && break
6935 done
6936 test -n "$LEX" || LEX="$MISSING flex"
6937
6938 case " $build_configdirs " in
6939   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6940   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6941 esac
6942
6943 for ac_prog in flex
6944 do
6945   # Extract the first word of "$ac_prog", so it can be a program name with args.
6946 set dummy $ac_prog; ac_word=$2
6947 echo "$as_me:$LINENO: checking for $ac_word" >&5
6948 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6949 if test "${ac_cv_prog_FLEX+set}" = set; then
6950   echo $ECHO_N "(cached) $ECHO_C" >&6
6951 else
6952   if test -n "$FLEX"; then
6953   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6954 else
6955 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6956 for as_dir in $PATH
6957 do
6958   IFS=$as_save_IFS
6959   test -z "$as_dir" && as_dir=.
6960   for ac_exec_ext in '' $ac_executable_extensions; do
6961   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6962     ac_cv_prog_FLEX="$ac_prog"
6963     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6964     break 2
6965   fi
6966 done
6967 done
6968
6969 fi
6970 fi
6971 FLEX=$ac_cv_prog_FLEX
6972 if test -n "$FLEX"; then
6973   echo "$as_me:$LINENO: result: $FLEX" >&5
6974 echo "${ECHO_T}$FLEX" >&6
6975 else
6976   echo "$as_me:$LINENO: result: no" >&5
6977 echo "${ECHO_T}no" >&6
6978 fi
6979
6980   test -n "$FLEX" && break
6981 done
6982 test -n "$FLEX" || FLEX="$MISSING flex"
6983
6984 case " $build_configdirs " in
6985   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6986 esac
6987
6988 for ac_prog in makeinfo
6989 do
6990   # Extract the first word of "$ac_prog", so it can be a program name with args.
6991 set dummy $ac_prog; ac_word=$2
6992 echo "$as_me:$LINENO: checking for $ac_word" >&5
6993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6994 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6995   echo $ECHO_N "(cached) $ECHO_C" >&6
6996 else
6997   if test -n "$MAKEINFO"; then
6998   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6999 else
7000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7001 for as_dir in $PATH
7002 do
7003   IFS=$as_save_IFS
7004   test -z "$as_dir" && as_dir=.
7005   for ac_exec_ext in '' $ac_executable_extensions; do
7006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7007     ac_cv_prog_MAKEINFO="$ac_prog"
7008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7009     break 2
7010   fi
7011 done
7012 done
7013
7014 fi
7015 fi
7016 MAKEINFO=$ac_cv_prog_MAKEINFO
7017 if test -n "$MAKEINFO"; then
7018   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
7019 echo "${ECHO_T}$MAKEINFO" >&6
7020 else
7021   echo "$as_me:$LINENO: result: no" >&5
7022 echo "${ECHO_T}no" >&6
7023 fi
7024
7025   test -n "$MAKEINFO" && break
7026 done
7027 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
7028
7029 case " $build_configdirs " in
7030   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
7031   *)
7032
7033     # For an installed makeinfo, we require it to be from texinfo 4.7 or
7034     # higher, else we use the "missing" dummy.
7035     if ${MAKEINFO} --version \
7036        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
7037       :
7038     else
7039       MAKEINFO="$MISSING makeinfo"
7040     fi
7041     ;;
7042
7043 esac
7044
7045 # FIXME: expect and dejagnu may become build tools?
7046
7047 for ac_prog in expect
7048 do
7049   # Extract the first word of "$ac_prog", so it can be a program name with args.
7050 set dummy $ac_prog; ac_word=$2
7051 echo "$as_me:$LINENO: checking for $ac_word" >&5
7052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7053 if test "${ac_cv_prog_EXPECT+set}" = set; then
7054   echo $ECHO_N "(cached) $ECHO_C" >&6
7055 else
7056   if test -n "$EXPECT"; then
7057   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
7058 else
7059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7060 for as_dir in $PATH
7061 do
7062   IFS=$as_save_IFS
7063   test -z "$as_dir" && as_dir=.
7064   for ac_exec_ext in '' $ac_executable_extensions; do
7065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7066     ac_cv_prog_EXPECT="$ac_prog"
7067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7068     break 2
7069   fi
7070 done
7071 done
7072
7073 fi
7074 fi
7075 EXPECT=$ac_cv_prog_EXPECT
7076 if test -n "$EXPECT"; then
7077   echo "$as_me:$LINENO: result: $EXPECT" >&5
7078 echo "${ECHO_T}$EXPECT" >&6
7079 else
7080   echo "$as_me:$LINENO: result: no" >&5
7081 echo "${ECHO_T}no" >&6
7082 fi
7083
7084   test -n "$EXPECT" && break
7085 done
7086 test -n "$EXPECT" || EXPECT="expect"
7087
7088 case " $configdirs " in
7089   *" expect "*)
7090     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
7091     ;;
7092 esac
7093
7094 for ac_prog in runtest
7095 do
7096   # Extract the first word of "$ac_prog", so it can be a program name with args.
7097 set dummy $ac_prog; ac_word=$2
7098 echo "$as_me:$LINENO: checking for $ac_word" >&5
7099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7100 if test "${ac_cv_prog_RUNTEST+set}" = set; then
7101   echo $ECHO_N "(cached) $ECHO_C" >&6
7102 else
7103   if test -n "$RUNTEST"; then
7104   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
7105 else
7106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7107 for as_dir in $PATH
7108 do
7109   IFS=$as_save_IFS
7110   test -z "$as_dir" && as_dir=.
7111   for ac_exec_ext in '' $ac_executable_extensions; do
7112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7113     ac_cv_prog_RUNTEST="$ac_prog"
7114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7115     break 2
7116   fi
7117 done
7118 done
7119
7120 fi
7121 fi
7122 RUNTEST=$ac_cv_prog_RUNTEST
7123 if test -n "$RUNTEST"; then
7124   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7125 echo "${ECHO_T}$RUNTEST" >&6
7126 else
7127   echo "$as_me:$LINENO: result: no" >&5
7128 echo "${ECHO_T}no" >&6
7129 fi
7130
7131   test -n "$RUNTEST" && break
7132 done
7133 test -n "$RUNTEST" || RUNTEST="runtest"
7134
7135 case " $configdirs " in
7136   *" dejagnu "*)
7137     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7138     ;;
7139 esac
7140
7141
7142 # Host tools.
7143 ncn_tool_prefix=
7144 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7145 ncn_target_tool_prefix=
7146 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7147
7148
7149
7150 if test -n "$AR"; then
7151   ac_cv_prog_AR=$AR
7152 elif test -n "$ac_cv_prog_AR"; then
7153   AR=$ac_cv_prog_AR
7154 fi
7155
7156 if test -n "$ac_cv_prog_AR"; then
7157   for ncn_progname in ar; do
7158     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7159 set dummy ${ncn_progname}; ac_word=$2
7160 echo "$as_me:$LINENO: checking for $ac_word" >&5
7161 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7162 if test "${ac_cv_prog_AR+set}" = set; then
7163   echo $ECHO_N "(cached) $ECHO_C" >&6
7164 else
7165   if test -n "$AR"; then
7166   ac_cv_prog_AR="$AR" # Let the user override the test.
7167 else
7168 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7169 for as_dir in $PATH
7170 do
7171   IFS=$as_save_IFS
7172   test -z "$as_dir" && as_dir=.
7173   for ac_exec_ext in '' $ac_executable_extensions; do
7174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7175     ac_cv_prog_AR="${ncn_progname}"
7176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7177     break 2
7178   fi
7179 done
7180 done
7181
7182 fi
7183 fi
7184 AR=$ac_cv_prog_AR
7185 if test -n "$AR"; then
7186   echo "$as_me:$LINENO: result: $AR" >&5
7187 echo "${ECHO_T}$AR" >&6
7188 else
7189   echo "$as_me:$LINENO: result: no" >&5
7190 echo "${ECHO_T}no" >&6
7191 fi
7192
7193   done
7194 fi
7195
7196 for ncn_progname in ar; do
7197   if test -n "$ncn_tool_prefix"; then
7198     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7199 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7200 echo "$as_me:$LINENO: checking for $ac_word" >&5
7201 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7202 if test "${ac_cv_prog_AR+set}" = set; then
7203   echo $ECHO_N "(cached) $ECHO_C" >&6
7204 else
7205   if test -n "$AR"; then
7206   ac_cv_prog_AR="$AR" # Let the user override the test.
7207 else
7208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7209 for as_dir in $PATH
7210 do
7211   IFS=$as_save_IFS
7212   test -z "$as_dir" && as_dir=.
7213   for ac_exec_ext in '' $ac_executable_extensions; do
7214   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7215     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7216     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7217     break 2
7218   fi
7219 done
7220 done
7221
7222 fi
7223 fi
7224 AR=$ac_cv_prog_AR
7225 if test -n "$AR"; then
7226   echo "$as_me:$LINENO: result: $AR" >&5
7227 echo "${ECHO_T}$AR" >&6
7228 else
7229   echo "$as_me:$LINENO: result: no" >&5
7230 echo "${ECHO_T}no" >&6
7231 fi
7232
7233   fi
7234   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7235     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7236 set dummy ${ncn_progname}; ac_word=$2
7237 echo "$as_me:$LINENO: checking for $ac_word" >&5
7238 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7239 if test "${ac_cv_prog_AR+set}" = set; then
7240   echo $ECHO_N "(cached) $ECHO_C" >&6
7241 else
7242   if test -n "$AR"; then
7243   ac_cv_prog_AR="$AR" # Let the user override the test.
7244 else
7245 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7246 for as_dir in $PATH
7247 do
7248   IFS=$as_save_IFS
7249   test -z "$as_dir" && as_dir=.
7250   for ac_exec_ext in '' $ac_executable_extensions; do
7251   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7252     ac_cv_prog_AR="${ncn_progname}"
7253     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7254     break 2
7255   fi
7256 done
7257 done
7258
7259 fi
7260 fi
7261 AR=$ac_cv_prog_AR
7262 if test -n "$AR"; then
7263   echo "$as_me:$LINENO: result: $AR" >&5
7264 echo "${ECHO_T}$AR" >&6
7265 else
7266   echo "$as_me:$LINENO: result: no" >&5
7267 echo "${ECHO_T}no" >&6
7268 fi
7269
7270   fi
7271   test -n "$ac_cv_prog_AR" && break
7272 done
7273
7274 if test -z "$ac_cv_prog_AR" ; then
7275   set dummy ar
7276   if test $build = $host ; then
7277     AR="$2"
7278   else
7279     AR="${ncn_tool_prefix}$2"
7280   fi
7281 fi
7282
7283
7284
7285 if test -n "$AS"; then
7286   ac_cv_prog_AS=$AS
7287 elif test -n "$ac_cv_prog_AS"; then
7288   AS=$ac_cv_prog_AS
7289 fi
7290
7291 if test -n "$ac_cv_prog_AS"; then
7292   for ncn_progname in as; do
7293     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7294 set dummy ${ncn_progname}; ac_word=$2
7295 echo "$as_me:$LINENO: checking for $ac_word" >&5
7296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7297 if test "${ac_cv_prog_AS+set}" = set; then
7298   echo $ECHO_N "(cached) $ECHO_C" >&6
7299 else
7300   if test -n "$AS"; then
7301   ac_cv_prog_AS="$AS" # Let the user override the test.
7302 else
7303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7304 for as_dir in $PATH
7305 do
7306   IFS=$as_save_IFS
7307   test -z "$as_dir" && as_dir=.
7308   for ac_exec_ext in '' $ac_executable_extensions; do
7309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7310     ac_cv_prog_AS="${ncn_progname}"
7311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7312     break 2
7313   fi
7314 done
7315 done
7316
7317 fi
7318 fi
7319 AS=$ac_cv_prog_AS
7320 if test -n "$AS"; then
7321   echo "$as_me:$LINENO: result: $AS" >&5
7322 echo "${ECHO_T}$AS" >&6
7323 else
7324   echo "$as_me:$LINENO: result: no" >&5
7325 echo "${ECHO_T}no" >&6
7326 fi
7327
7328   done
7329 fi
7330
7331 for ncn_progname in as; do
7332   if test -n "$ncn_tool_prefix"; then
7333     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7334 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7335 echo "$as_me:$LINENO: checking for $ac_word" >&5
7336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7337 if test "${ac_cv_prog_AS+set}" = set; then
7338   echo $ECHO_N "(cached) $ECHO_C" >&6
7339 else
7340   if test -n "$AS"; then
7341   ac_cv_prog_AS="$AS" # Let the user override the test.
7342 else
7343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7344 for as_dir in $PATH
7345 do
7346   IFS=$as_save_IFS
7347   test -z "$as_dir" && as_dir=.
7348   for ac_exec_ext in '' $ac_executable_extensions; do
7349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7350     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7352     break 2
7353   fi
7354 done
7355 done
7356
7357 fi
7358 fi
7359 AS=$ac_cv_prog_AS
7360 if test -n "$AS"; then
7361   echo "$as_me:$LINENO: result: $AS" >&5
7362 echo "${ECHO_T}$AS" >&6
7363 else
7364   echo "$as_me:$LINENO: result: no" >&5
7365 echo "${ECHO_T}no" >&6
7366 fi
7367
7368   fi
7369   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7370     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7371 set dummy ${ncn_progname}; ac_word=$2
7372 echo "$as_me:$LINENO: checking for $ac_word" >&5
7373 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7374 if test "${ac_cv_prog_AS+set}" = set; then
7375   echo $ECHO_N "(cached) $ECHO_C" >&6
7376 else
7377   if test -n "$AS"; then
7378   ac_cv_prog_AS="$AS" # Let the user override the test.
7379 else
7380 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7381 for as_dir in $PATH
7382 do
7383   IFS=$as_save_IFS
7384   test -z "$as_dir" && as_dir=.
7385   for ac_exec_ext in '' $ac_executable_extensions; do
7386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7387     ac_cv_prog_AS="${ncn_progname}"
7388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7389     break 2
7390   fi
7391 done
7392 done
7393
7394 fi
7395 fi
7396 AS=$ac_cv_prog_AS
7397 if test -n "$AS"; then
7398   echo "$as_me:$LINENO: result: $AS" >&5
7399 echo "${ECHO_T}$AS" >&6
7400 else
7401   echo "$as_me:$LINENO: result: no" >&5
7402 echo "${ECHO_T}no" >&6
7403 fi
7404
7405   fi
7406   test -n "$ac_cv_prog_AS" && break
7407 done
7408
7409 if test -z "$ac_cv_prog_AS" ; then
7410   set dummy as
7411   if test $build = $host ; then
7412     AS="$2"
7413   else
7414     AS="${ncn_tool_prefix}$2"
7415   fi
7416 fi
7417
7418
7419
7420 if test -n "$DLLTOOL"; then
7421   ac_cv_prog_DLLTOOL=$DLLTOOL
7422 elif test -n "$ac_cv_prog_DLLTOOL"; then
7423   DLLTOOL=$ac_cv_prog_DLLTOOL
7424 fi
7425
7426 if test -n "$ac_cv_prog_DLLTOOL"; then
7427   for ncn_progname in dlltool; do
7428     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7429 set dummy ${ncn_progname}; ac_word=$2
7430 echo "$as_me:$LINENO: checking for $ac_word" >&5
7431 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7432 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7433   echo $ECHO_N "(cached) $ECHO_C" >&6
7434 else
7435   if test -n "$DLLTOOL"; then
7436   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7437 else
7438 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7439 for as_dir in $PATH
7440 do
7441   IFS=$as_save_IFS
7442   test -z "$as_dir" && as_dir=.
7443   for ac_exec_ext in '' $ac_executable_extensions; do
7444   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7445     ac_cv_prog_DLLTOOL="${ncn_progname}"
7446     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7447     break 2
7448   fi
7449 done
7450 done
7451
7452 fi
7453 fi
7454 DLLTOOL=$ac_cv_prog_DLLTOOL
7455 if test -n "$DLLTOOL"; then
7456   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7457 echo "${ECHO_T}$DLLTOOL" >&6
7458 else
7459   echo "$as_me:$LINENO: result: no" >&5
7460 echo "${ECHO_T}no" >&6
7461 fi
7462
7463   done
7464 fi
7465
7466 for ncn_progname in dlltool; do
7467   if test -n "$ncn_tool_prefix"; then
7468     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7469 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7470 echo "$as_me:$LINENO: checking for $ac_word" >&5
7471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7472 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7473   echo $ECHO_N "(cached) $ECHO_C" >&6
7474 else
7475   if test -n "$DLLTOOL"; then
7476   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7477 else
7478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7479 for as_dir in $PATH
7480 do
7481   IFS=$as_save_IFS
7482   test -z "$as_dir" && as_dir=.
7483   for ac_exec_ext in '' $ac_executable_extensions; do
7484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7485     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7487     break 2
7488   fi
7489 done
7490 done
7491
7492 fi
7493 fi
7494 DLLTOOL=$ac_cv_prog_DLLTOOL
7495 if test -n "$DLLTOOL"; then
7496   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7497 echo "${ECHO_T}$DLLTOOL" >&6
7498 else
7499   echo "$as_me:$LINENO: result: no" >&5
7500 echo "${ECHO_T}no" >&6
7501 fi
7502
7503   fi
7504   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7505     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7506 set dummy ${ncn_progname}; ac_word=$2
7507 echo "$as_me:$LINENO: checking for $ac_word" >&5
7508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7509 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7510   echo $ECHO_N "(cached) $ECHO_C" >&6
7511 else
7512   if test -n "$DLLTOOL"; then
7513   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7514 else
7515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7516 for as_dir in $PATH
7517 do
7518   IFS=$as_save_IFS
7519   test -z "$as_dir" && as_dir=.
7520   for ac_exec_ext in '' $ac_executable_extensions; do
7521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7522     ac_cv_prog_DLLTOOL="${ncn_progname}"
7523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7524     break 2
7525   fi
7526 done
7527 done
7528
7529 fi
7530 fi
7531 DLLTOOL=$ac_cv_prog_DLLTOOL
7532 if test -n "$DLLTOOL"; then
7533   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7534 echo "${ECHO_T}$DLLTOOL" >&6
7535 else
7536   echo "$as_me:$LINENO: result: no" >&5
7537 echo "${ECHO_T}no" >&6
7538 fi
7539
7540   fi
7541   test -n "$ac_cv_prog_DLLTOOL" && break
7542 done
7543
7544 if test -z "$ac_cv_prog_DLLTOOL" ; then
7545   set dummy dlltool
7546   if test $build = $host ; then
7547     DLLTOOL="$2"
7548   else
7549     DLLTOOL="${ncn_tool_prefix}$2"
7550   fi
7551 fi
7552
7553
7554
7555 if test -n "$LD"; then
7556   ac_cv_prog_LD=$LD
7557 elif test -n "$ac_cv_prog_LD"; then
7558   LD=$ac_cv_prog_LD
7559 fi
7560
7561 if test -n "$ac_cv_prog_LD"; then
7562   for ncn_progname in ld; do
7563     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7564 set dummy ${ncn_progname}; ac_word=$2
7565 echo "$as_me:$LINENO: checking for $ac_word" >&5
7566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7567 if test "${ac_cv_prog_LD+set}" = set; then
7568   echo $ECHO_N "(cached) $ECHO_C" >&6
7569 else
7570   if test -n "$LD"; then
7571   ac_cv_prog_LD="$LD" # Let the user override the test.
7572 else
7573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7574 for as_dir in $PATH
7575 do
7576   IFS=$as_save_IFS
7577   test -z "$as_dir" && as_dir=.
7578   for ac_exec_ext in '' $ac_executable_extensions; do
7579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7580     ac_cv_prog_LD="${ncn_progname}"
7581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7582     break 2
7583   fi
7584 done
7585 done
7586
7587 fi
7588 fi
7589 LD=$ac_cv_prog_LD
7590 if test -n "$LD"; then
7591   echo "$as_me:$LINENO: result: $LD" >&5
7592 echo "${ECHO_T}$LD" >&6
7593 else
7594   echo "$as_me:$LINENO: result: no" >&5
7595 echo "${ECHO_T}no" >&6
7596 fi
7597
7598   done
7599 fi
7600
7601 for ncn_progname in ld; do
7602   if test -n "$ncn_tool_prefix"; then
7603     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7604 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7605 echo "$as_me:$LINENO: checking for $ac_word" >&5
7606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7607 if test "${ac_cv_prog_LD+set}" = set; then
7608   echo $ECHO_N "(cached) $ECHO_C" >&6
7609 else
7610   if test -n "$LD"; then
7611   ac_cv_prog_LD="$LD" # Let the user override the test.
7612 else
7613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7614 for as_dir in $PATH
7615 do
7616   IFS=$as_save_IFS
7617   test -z "$as_dir" && as_dir=.
7618   for ac_exec_ext in '' $ac_executable_extensions; do
7619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7620     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7622     break 2
7623   fi
7624 done
7625 done
7626
7627 fi
7628 fi
7629 LD=$ac_cv_prog_LD
7630 if test -n "$LD"; then
7631   echo "$as_me:$LINENO: result: $LD" >&5
7632 echo "${ECHO_T}$LD" >&6
7633 else
7634   echo "$as_me:$LINENO: result: no" >&5
7635 echo "${ECHO_T}no" >&6
7636 fi
7637
7638   fi
7639   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7640     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7641 set dummy ${ncn_progname}; ac_word=$2
7642 echo "$as_me:$LINENO: checking for $ac_word" >&5
7643 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7644 if test "${ac_cv_prog_LD+set}" = set; then
7645   echo $ECHO_N "(cached) $ECHO_C" >&6
7646 else
7647   if test -n "$LD"; then
7648   ac_cv_prog_LD="$LD" # Let the user override the test.
7649 else
7650 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7651 for as_dir in $PATH
7652 do
7653   IFS=$as_save_IFS
7654   test -z "$as_dir" && as_dir=.
7655   for ac_exec_ext in '' $ac_executable_extensions; do
7656   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7657     ac_cv_prog_LD="${ncn_progname}"
7658     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7659     break 2
7660   fi
7661 done
7662 done
7663
7664 fi
7665 fi
7666 LD=$ac_cv_prog_LD
7667 if test -n "$LD"; then
7668   echo "$as_me:$LINENO: result: $LD" >&5
7669 echo "${ECHO_T}$LD" >&6
7670 else
7671   echo "$as_me:$LINENO: result: no" >&5
7672 echo "${ECHO_T}no" >&6
7673 fi
7674
7675   fi
7676   test -n "$ac_cv_prog_LD" && break
7677 done
7678
7679 if test -z "$ac_cv_prog_LD" ; then
7680   set dummy ld
7681   if test $build = $host ; then
7682     LD="$2"
7683   else
7684     LD="${ncn_tool_prefix}$2"
7685   fi
7686 fi
7687
7688
7689
7690 if test -n "$LIPO"; then
7691   ac_cv_prog_LIPO=$LIPO
7692 elif test -n "$ac_cv_prog_LIPO"; then
7693   LIPO=$ac_cv_prog_LIPO
7694 fi
7695
7696 if test -n "$ac_cv_prog_LIPO"; then
7697   for ncn_progname in lipo; do
7698     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7699 set dummy ${ncn_progname}; ac_word=$2
7700 echo "$as_me:$LINENO: checking for $ac_word" >&5
7701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7702 if test "${ac_cv_prog_LIPO+set}" = set; then
7703   echo $ECHO_N "(cached) $ECHO_C" >&6
7704 else
7705   if test -n "$LIPO"; then
7706   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7707 else
7708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7709 for as_dir in $PATH
7710 do
7711   IFS=$as_save_IFS
7712   test -z "$as_dir" && as_dir=.
7713   for ac_exec_ext in '' $ac_executable_extensions; do
7714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7715     ac_cv_prog_LIPO="${ncn_progname}"
7716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7717     break 2
7718   fi
7719 done
7720 done
7721
7722 fi
7723 fi
7724 LIPO=$ac_cv_prog_LIPO
7725 if test -n "$LIPO"; then
7726   echo "$as_me:$LINENO: result: $LIPO" >&5
7727 echo "${ECHO_T}$LIPO" >&6
7728 else
7729   echo "$as_me:$LINENO: result: no" >&5
7730 echo "${ECHO_T}no" >&6
7731 fi
7732
7733   done
7734 fi
7735
7736 for ncn_progname in lipo; do
7737   if test -n "$ncn_tool_prefix"; then
7738     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7739 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7740 echo "$as_me:$LINENO: checking for $ac_word" >&5
7741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7742 if test "${ac_cv_prog_LIPO+set}" = set; then
7743   echo $ECHO_N "(cached) $ECHO_C" >&6
7744 else
7745   if test -n "$LIPO"; then
7746   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7747 else
7748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7749 for as_dir in $PATH
7750 do
7751   IFS=$as_save_IFS
7752   test -z "$as_dir" && as_dir=.
7753   for ac_exec_ext in '' $ac_executable_extensions; do
7754   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7755     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7756     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7757     break 2
7758   fi
7759 done
7760 done
7761
7762 fi
7763 fi
7764 LIPO=$ac_cv_prog_LIPO
7765 if test -n "$LIPO"; then
7766   echo "$as_me:$LINENO: result: $LIPO" >&5
7767 echo "${ECHO_T}$LIPO" >&6
7768 else
7769   echo "$as_me:$LINENO: result: no" >&5
7770 echo "${ECHO_T}no" >&6
7771 fi
7772
7773   fi
7774   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7775     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7776 set dummy ${ncn_progname}; ac_word=$2
7777 echo "$as_me:$LINENO: checking for $ac_word" >&5
7778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7779 if test "${ac_cv_prog_LIPO+set}" = set; then
7780   echo $ECHO_N "(cached) $ECHO_C" >&6
7781 else
7782   if test -n "$LIPO"; then
7783   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7784 else
7785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7786 for as_dir in $PATH
7787 do
7788   IFS=$as_save_IFS
7789   test -z "$as_dir" && as_dir=.
7790   for ac_exec_ext in '' $ac_executable_extensions; do
7791   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7792     ac_cv_prog_LIPO="${ncn_progname}"
7793     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7794     break 2
7795   fi
7796 done
7797 done
7798
7799 fi
7800 fi
7801 LIPO=$ac_cv_prog_LIPO
7802 if test -n "$LIPO"; then
7803   echo "$as_me:$LINENO: result: $LIPO" >&5
7804 echo "${ECHO_T}$LIPO" >&6
7805 else
7806   echo "$as_me:$LINENO: result: no" >&5
7807 echo "${ECHO_T}no" >&6
7808 fi
7809
7810   fi
7811   test -n "$ac_cv_prog_LIPO" && break
7812 done
7813
7814 if test -z "$ac_cv_prog_LIPO" ; then
7815   set dummy lipo
7816   if test $build = $host ; then
7817     LIPO="$2"
7818   else
7819     LIPO="${ncn_tool_prefix}$2"
7820   fi
7821 fi
7822
7823
7824
7825 if test -n "$NM"; then
7826   ac_cv_prog_NM=$NM
7827 elif test -n "$ac_cv_prog_NM"; then
7828   NM=$ac_cv_prog_NM
7829 fi
7830
7831 if test -n "$ac_cv_prog_NM"; then
7832   for ncn_progname in nm; do
7833     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7834 set dummy ${ncn_progname}; ac_word=$2
7835 echo "$as_me:$LINENO: checking for $ac_word" >&5
7836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7837 if test "${ac_cv_prog_NM+set}" = set; then
7838   echo $ECHO_N "(cached) $ECHO_C" >&6
7839 else
7840   if test -n "$NM"; then
7841   ac_cv_prog_NM="$NM" # Let the user override the test.
7842 else
7843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7844 for as_dir in $PATH
7845 do
7846   IFS=$as_save_IFS
7847   test -z "$as_dir" && as_dir=.
7848   for ac_exec_ext in '' $ac_executable_extensions; do
7849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7850     ac_cv_prog_NM="${ncn_progname}"
7851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7852     break 2
7853   fi
7854 done
7855 done
7856
7857 fi
7858 fi
7859 NM=$ac_cv_prog_NM
7860 if test -n "$NM"; then
7861   echo "$as_me:$LINENO: result: $NM" >&5
7862 echo "${ECHO_T}$NM" >&6
7863 else
7864   echo "$as_me:$LINENO: result: no" >&5
7865 echo "${ECHO_T}no" >&6
7866 fi
7867
7868   done
7869 fi
7870
7871 for ncn_progname in nm; do
7872   if test -n "$ncn_tool_prefix"; then
7873     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7874 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7875 echo "$as_me:$LINENO: checking for $ac_word" >&5
7876 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7877 if test "${ac_cv_prog_NM+set}" = set; then
7878   echo $ECHO_N "(cached) $ECHO_C" >&6
7879 else
7880   if test -n "$NM"; then
7881   ac_cv_prog_NM="$NM" # Let the user override the test.
7882 else
7883 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7884 for as_dir in $PATH
7885 do
7886   IFS=$as_save_IFS
7887   test -z "$as_dir" && as_dir=.
7888   for ac_exec_ext in '' $ac_executable_extensions; do
7889   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7890     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7891     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7892     break 2
7893   fi
7894 done
7895 done
7896
7897 fi
7898 fi
7899 NM=$ac_cv_prog_NM
7900 if test -n "$NM"; then
7901   echo "$as_me:$LINENO: result: $NM" >&5
7902 echo "${ECHO_T}$NM" >&6
7903 else
7904   echo "$as_me:$LINENO: result: no" >&5
7905 echo "${ECHO_T}no" >&6
7906 fi
7907
7908   fi
7909   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7910     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7911 set dummy ${ncn_progname}; ac_word=$2
7912 echo "$as_me:$LINENO: checking for $ac_word" >&5
7913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7914 if test "${ac_cv_prog_NM+set}" = set; then
7915   echo $ECHO_N "(cached) $ECHO_C" >&6
7916 else
7917   if test -n "$NM"; then
7918   ac_cv_prog_NM="$NM" # Let the user override the test.
7919 else
7920 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7921 for as_dir in $PATH
7922 do
7923   IFS=$as_save_IFS
7924   test -z "$as_dir" && as_dir=.
7925   for ac_exec_ext in '' $ac_executable_extensions; do
7926   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7927     ac_cv_prog_NM="${ncn_progname}"
7928     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7929     break 2
7930   fi
7931 done
7932 done
7933
7934 fi
7935 fi
7936 NM=$ac_cv_prog_NM
7937 if test -n "$NM"; then
7938   echo "$as_me:$LINENO: result: $NM" >&5
7939 echo "${ECHO_T}$NM" >&6
7940 else
7941   echo "$as_me:$LINENO: result: no" >&5
7942 echo "${ECHO_T}no" >&6
7943 fi
7944
7945   fi
7946   test -n "$ac_cv_prog_NM" && break
7947 done
7948
7949 if test -z "$ac_cv_prog_NM" ; then
7950   set dummy nm
7951   if test $build = $host ; then
7952     NM="$2"
7953   else
7954     NM="${ncn_tool_prefix}$2"
7955   fi
7956 fi
7957
7958
7959
7960 if test -n "$RANLIB"; then
7961   ac_cv_prog_RANLIB=$RANLIB
7962 elif test -n "$ac_cv_prog_RANLIB"; then
7963   RANLIB=$ac_cv_prog_RANLIB
7964 fi
7965
7966 if test -n "$ac_cv_prog_RANLIB"; then
7967   for ncn_progname in ranlib; do
7968     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7969 set dummy ${ncn_progname}; ac_word=$2
7970 echo "$as_me:$LINENO: checking for $ac_word" >&5
7971 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7972 if test "${ac_cv_prog_RANLIB+set}" = set; then
7973   echo $ECHO_N "(cached) $ECHO_C" >&6
7974 else
7975   if test -n "$RANLIB"; then
7976   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7977 else
7978 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7979 for as_dir in $PATH
7980 do
7981   IFS=$as_save_IFS
7982   test -z "$as_dir" && as_dir=.
7983   for ac_exec_ext in '' $ac_executable_extensions; do
7984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7985     ac_cv_prog_RANLIB="${ncn_progname}"
7986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7987     break 2
7988   fi
7989 done
7990 done
7991
7992 fi
7993 fi
7994 RANLIB=$ac_cv_prog_RANLIB
7995 if test -n "$RANLIB"; then
7996   echo "$as_me:$LINENO: result: $RANLIB" >&5
7997 echo "${ECHO_T}$RANLIB" >&6
7998 else
7999   echo "$as_me:$LINENO: result: no" >&5
8000 echo "${ECHO_T}no" >&6
8001 fi
8002
8003   done
8004 fi
8005
8006 for ncn_progname in ranlib; do
8007   if test -n "$ncn_tool_prefix"; then
8008     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8009 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8010 echo "$as_me:$LINENO: checking for $ac_word" >&5
8011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8012 if test "${ac_cv_prog_RANLIB+set}" = set; then
8013   echo $ECHO_N "(cached) $ECHO_C" >&6
8014 else
8015   if test -n "$RANLIB"; then
8016   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8017 else
8018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8019 for as_dir in $PATH
8020 do
8021   IFS=$as_save_IFS
8022   test -z "$as_dir" && as_dir=.
8023   for ac_exec_ext in '' $ac_executable_extensions; do
8024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8025     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
8026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8027     break 2
8028   fi
8029 done
8030 done
8031
8032 fi
8033 fi
8034 RANLIB=$ac_cv_prog_RANLIB
8035 if test -n "$RANLIB"; then
8036   echo "$as_me:$LINENO: result: $RANLIB" >&5
8037 echo "${ECHO_T}$RANLIB" >&6
8038 else
8039   echo "$as_me:$LINENO: result: no" >&5
8040 echo "${ECHO_T}no" >&6
8041 fi
8042
8043   fi
8044   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
8045     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8046 set dummy ${ncn_progname}; ac_word=$2
8047 echo "$as_me:$LINENO: checking for $ac_word" >&5
8048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8049 if test "${ac_cv_prog_RANLIB+set}" = set; then
8050   echo $ECHO_N "(cached) $ECHO_C" >&6
8051 else
8052   if test -n "$RANLIB"; then
8053   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8054 else
8055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8056 for as_dir in $PATH
8057 do
8058   IFS=$as_save_IFS
8059   test -z "$as_dir" && as_dir=.
8060   for ac_exec_ext in '' $ac_executable_extensions; do
8061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8062     ac_cv_prog_RANLIB="${ncn_progname}"
8063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8064     break 2
8065   fi
8066 done
8067 done
8068
8069 fi
8070 fi
8071 RANLIB=$ac_cv_prog_RANLIB
8072 if test -n "$RANLIB"; then
8073   echo "$as_me:$LINENO: result: $RANLIB" >&5
8074 echo "${ECHO_T}$RANLIB" >&6
8075 else
8076   echo "$as_me:$LINENO: result: no" >&5
8077 echo "${ECHO_T}no" >&6
8078 fi
8079
8080   fi
8081   test -n "$ac_cv_prog_RANLIB" && break
8082 done
8083
8084 if test -z "$ac_cv_prog_RANLIB" ; then
8085   RANLIB=":"
8086 fi
8087
8088
8089
8090 if test -n "$STRIP"; then
8091   ac_cv_prog_STRIP=$STRIP
8092 elif test -n "$ac_cv_prog_STRIP"; then
8093   STRIP=$ac_cv_prog_STRIP
8094 fi
8095
8096 if test -n "$ac_cv_prog_STRIP"; then
8097   for ncn_progname in strip; do
8098     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8099 set dummy ${ncn_progname}; ac_word=$2
8100 echo "$as_me:$LINENO: checking for $ac_word" >&5
8101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8102 if test "${ac_cv_prog_STRIP+set}" = set; then
8103   echo $ECHO_N "(cached) $ECHO_C" >&6
8104 else
8105   if test -n "$STRIP"; then
8106   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8107 else
8108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8109 for as_dir in $PATH
8110 do
8111   IFS=$as_save_IFS
8112   test -z "$as_dir" && as_dir=.
8113   for ac_exec_ext in '' $ac_executable_extensions; do
8114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8115     ac_cv_prog_STRIP="${ncn_progname}"
8116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8117     break 2
8118   fi
8119 done
8120 done
8121
8122 fi
8123 fi
8124 STRIP=$ac_cv_prog_STRIP
8125 if test -n "$STRIP"; then
8126   echo "$as_me:$LINENO: result: $STRIP" >&5
8127 echo "${ECHO_T}$STRIP" >&6
8128 else
8129   echo "$as_me:$LINENO: result: no" >&5
8130 echo "${ECHO_T}no" >&6
8131 fi
8132
8133   done
8134 fi
8135
8136 for ncn_progname in strip; do
8137   if test -n "$ncn_tool_prefix"; then
8138     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8139 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8140 echo "$as_me:$LINENO: checking for $ac_word" >&5
8141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8142 if test "${ac_cv_prog_STRIP+set}" = set; then
8143   echo $ECHO_N "(cached) $ECHO_C" >&6
8144 else
8145   if test -n "$STRIP"; then
8146   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8147 else
8148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8149 for as_dir in $PATH
8150 do
8151   IFS=$as_save_IFS
8152   test -z "$as_dir" && as_dir=.
8153   for ac_exec_ext in '' $ac_executable_extensions; do
8154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8155     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8157     break 2
8158   fi
8159 done
8160 done
8161
8162 fi
8163 fi
8164 STRIP=$ac_cv_prog_STRIP
8165 if test -n "$STRIP"; then
8166   echo "$as_me:$LINENO: result: $STRIP" >&5
8167 echo "${ECHO_T}$STRIP" >&6
8168 else
8169   echo "$as_me:$LINENO: result: no" >&5
8170 echo "${ECHO_T}no" >&6
8171 fi
8172
8173   fi
8174   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8175     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8176 set dummy ${ncn_progname}; ac_word=$2
8177 echo "$as_me:$LINENO: checking for $ac_word" >&5
8178 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8179 if test "${ac_cv_prog_STRIP+set}" = set; then
8180   echo $ECHO_N "(cached) $ECHO_C" >&6
8181 else
8182   if test -n "$STRIP"; then
8183   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8184 else
8185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8186 for as_dir in $PATH
8187 do
8188   IFS=$as_save_IFS
8189   test -z "$as_dir" && as_dir=.
8190   for ac_exec_ext in '' $ac_executable_extensions; do
8191   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8192     ac_cv_prog_STRIP="${ncn_progname}"
8193     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8194     break 2
8195   fi
8196 done
8197 done
8198
8199 fi
8200 fi
8201 STRIP=$ac_cv_prog_STRIP
8202 if test -n "$STRIP"; then
8203   echo "$as_me:$LINENO: result: $STRIP" >&5
8204 echo "${ECHO_T}$STRIP" >&6
8205 else
8206   echo "$as_me:$LINENO: result: no" >&5
8207 echo "${ECHO_T}no" >&6
8208 fi
8209
8210   fi
8211   test -n "$ac_cv_prog_STRIP" && break
8212 done
8213
8214 if test -z "$ac_cv_prog_STRIP" ; then
8215   STRIP=":"
8216 fi
8217
8218
8219
8220 if test -n "$WINDRES"; then
8221   ac_cv_prog_WINDRES=$WINDRES
8222 elif test -n "$ac_cv_prog_WINDRES"; then
8223   WINDRES=$ac_cv_prog_WINDRES
8224 fi
8225
8226 if test -n "$ac_cv_prog_WINDRES"; then
8227   for ncn_progname in windres; do
8228     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8229 set dummy ${ncn_progname}; ac_word=$2
8230 echo "$as_me:$LINENO: checking for $ac_word" >&5
8231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8232 if test "${ac_cv_prog_WINDRES+set}" = set; then
8233   echo $ECHO_N "(cached) $ECHO_C" >&6
8234 else
8235   if test -n "$WINDRES"; then
8236   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8237 else
8238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8239 for as_dir in $PATH
8240 do
8241   IFS=$as_save_IFS
8242   test -z "$as_dir" && as_dir=.
8243   for ac_exec_ext in '' $ac_executable_extensions; do
8244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8245     ac_cv_prog_WINDRES="${ncn_progname}"
8246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8247     break 2
8248   fi
8249 done
8250 done
8251
8252 fi
8253 fi
8254 WINDRES=$ac_cv_prog_WINDRES
8255 if test -n "$WINDRES"; then
8256   echo "$as_me:$LINENO: result: $WINDRES" >&5
8257 echo "${ECHO_T}$WINDRES" >&6
8258 else
8259   echo "$as_me:$LINENO: result: no" >&5
8260 echo "${ECHO_T}no" >&6
8261 fi
8262
8263   done
8264 fi
8265
8266 for ncn_progname in windres; do
8267   if test -n "$ncn_tool_prefix"; then
8268     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8269 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8270 echo "$as_me:$LINENO: checking for $ac_word" >&5
8271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8272 if test "${ac_cv_prog_WINDRES+set}" = set; then
8273   echo $ECHO_N "(cached) $ECHO_C" >&6
8274 else
8275   if test -n "$WINDRES"; then
8276   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8277 else
8278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8279 for as_dir in $PATH
8280 do
8281   IFS=$as_save_IFS
8282   test -z "$as_dir" && as_dir=.
8283   for ac_exec_ext in '' $ac_executable_extensions; do
8284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8285     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8287     break 2
8288   fi
8289 done
8290 done
8291
8292 fi
8293 fi
8294 WINDRES=$ac_cv_prog_WINDRES
8295 if test -n "$WINDRES"; then
8296   echo "$as_me:$LINENO: result: $WINDRES" >&5
8297 echo "${ECHO_T}$WINDRES" >&6
8298 else
8299   echo "$as_me:$LINENO: result: no" >&5
8300 echo "${ECHO_T}no" >&6
8301 fi
8302
8303   fi
8304   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8305     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8306 set dummy ${ncn_progname}; ac_word=$2
8307 echo "$as_me:$LINENO: checking for $ac_word" >&5
8308 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8309 if test "${ac_cv_prog_WINDRES+set}" = set; then
8310   echo $ECHO_N "(cached) $ECHO_C" >&6
8311 else
8312   if test -n "$WINDRES"; then
8313   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8314 else
8315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8316 for as_dir in $PATH
8317 do
8318   IFS=$as_save_IFS
8319   test -z "$as_dir" && as_dir=.
8320   for ac_exec_ext in '' $ac_executable_extensions; do
8321   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8322     ac_cv_prog_WINDRES="${ncn_progname}"
8323     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8324     break 2
8325   fi
8326 done
8327 done
8328
8329 fi
8330 fi
8331 WINDRES=$ac_cv_prog_WINDRES
8332 if test -n "$WINDRES"; then
8333   echo "$as_me:$LINENO: result: $WINDRES" >&5
8334 echo "${ECHO_T}$WINDRES" >&6
8335 else
8336   echo "$as_me:$LINENO: result: no" >&5
8337 echo "${ECHO_T}no" >&6
8338 fi
8339
8340   fi
8341   test -n "$ac_cv_prog_WINDRES" && break
8342 done
8343
8344 if test -z "$ac_cv_prog_WINDRES" ; then
8345   set dummy windres
8346   if test $build = $host ; then
8347     WINDRES="$2"
8348   else
8349     WINDRES="${ncn_tool_prefix}$2"
8350   fi
8351 fi
8352
8353
8354
8355 if test -n "$WINDMC"; then
8356   ac_cv_prog_WINDMC=$WINDMC
8357 elif test -n "$ac_cv_prog_WINDMC"; then
8358   WINDMC=$ac_cv_prog_WINDMC
8359 fi
8360
8361 if test -n "$ac_cv_prog_WINDMC"; then
8362   for ncn_progname in windmc; do
8363     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8364 set dummy ${ncn_progname}; ac_word=$2
8365 echo "$as_me:$LINENO: checking for $ac_word" >&5
8366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8367 if test "${ac_cv_prog_WINDMC+set}" = set; then
8368   echo $ECHO_N "(cached) $ECHO_C" >&6
8369 else
8370   if test -n "$WINDMC"; then
8371   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8372 else
8373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8374 for as_dir in $PATH
8375 do
8376   IFS=$as_save_IFS
8377   test -z "$as_dir" && as_dir=.
8378   for ac_exec_ext in '' $ac_executable_extensions; do
8379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8380     ac_cv_prog_WINDMC="${ncn_progname}"
8381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8382     break 2
8383   fi
8384 done
8385 done
8386
8387 fi
8388 fi
8389 WINDMC=$ac_cv_prog_WINDMC
8390 if test -n "$WINDMC"; then
8391   echo "$as_me:$LINENO: result: $WINDMC" >&5
8392 echo "${ECHO_T}$WINDMC" >&6
8393 else
8394   echo "$as_me:$LINENO: result: no" >&5
8395 echo "${ECHO_T}no" >&6
8396 fi
8397
8398   done
8399 fi
8400
8401 for ncn_progname in windmc; do
8402   if test -n "$ncn_tool_prefix"; then
8403     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8404 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8405 echo "$as_me:$LINENO: checking for $ac_word" >&5
8406 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8407 if test "${ac_cv_prog_WINDMC+set}" = set; then
8408   echo $ECHO_N "(cached) $ECHO_C" >&6
8409 else
8410   if test -n "$WINDMC"; then
8411   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8412 else
8413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8414 for as_dir in $PATH
8415 do
8416   IFS=$as_save_IFS
8417   test -z "$as_dir" && as_dir=.
8418   for ac_exec_ext in '' $ac_executable_extensions; do
8419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8420     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8422     break 2
8423   fi
8424 done
8425 done
8426
8427 fi
8428 fi
8429 WINDMC=$ac_cv_prog_WINDMC
8430 if test -n "$WINDMC"; then
8431   echo "$as_me:$LINENO: result: $WINDMC" >&5
8432 echo "${ECHO_T}$WINDMC" >&6
8433 else
8434   echo "$as_me:$LINENO: result: no" >&5
8435 echo "${ECHO_T}no" >&6
8436 fi
8437
8438   fi
8439   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8440     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8441 set dummy ${ncn_progname}; ac_word=$2
8442 echo "$as_me:$LINENO: checking for $ac_word" >&5
8443 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8444 if test "${ac_cv_prog_WINDMC+set}" = set; then
8445   echo $ECHO_N "(cached) $ECHO_C" >&6
8446 else
8447   if test -n "$WINDMC"; then
8448   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8449 else
8450 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8451 for as_dir in $PATH
8452 do
8453   IFS=$as_save_IFS
8454   test -z "$as_dir" && as_dir=.
8455   for ac_exec_ext in '' $ac_executable_extensions; do
8456   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8457     ac_cv_prog_WINDMC="${ncn_progname}"
8458     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8459     break 2
8460   fi
8461 done
8462 done
8463
8464 fi
8465 fi
8466 WINDMC=$ac_cv_prog_WINDMC
8467 if test -n "$WINDMC"; then
8468   echo "$as_me:$LINENO: result: $WINDMC" >&5
8469 echo "${ECHO_T}$WINDMC" >&6
8470 else
8471   echo "$as_me:$LINENO: result: no" >&5
8472 echo "${ECHO_T}no" >&6
8473 fi
8474
8475   fi
8476   test -n "$ac_cv_prog_WINDMC" && break
8477 done
8478
8479 if test -z "$ac_cv_prog_WINDMC" ; then
8480   set dummy windmc
8481   if test $build = $host ; then
8482     WINDMC="$2"
8483   else
8484     WINDMC="${ncn_tool_prefix}$2"
8485   fi
8486 fi
8487
8488
8489
8490 if test -n "$OBJCOPY"; then
8491   ac_cv_prog_OBJCOPY=$OBJCOPY
8492 elif test -n "$ac_cv_prog_OBJCOPY"; then
8493   OBJCOPY=$ac_cv_prog_OBJCOPY
8494 fi
8495
8496 if test -n "$ac_cv_prog_OBJCOPY"; then
8497   for ncn_progname in objcopy; do
8498     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8499 set dummy ${ncn_progname}; ac_word=$2
8500 echo "$as_me:$LINENO: checking for $ac_word" >&5
8501 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8502 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8503   echo $ECHO_N "(cached) $ECHO_C" >&6
8504 else
8505   if test -n "$OBJCOPY"; then
8506   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8507 else
8508 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8509 for as_dir in $PATH
8510 do
8511   IFS=$as_save_IFS
8512   test -z "$as_dir" && as_dir=.
8513   for ac_exec_ext in '' $ac_executable_extensions; do
8514   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8515     ac_cv_prog_OBJCOPY="${ncn_progname}"
8516     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8517     break 2
8518   fi
8519 done
8520 done
8521
8522 fi
8523 fi
8524 OBJCOPY=$ac_cv_prog_OBJCOPY
8525 if test -n "$OBJCOPY"; then
8526   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8527 echo "${ECHO_T}$OBJCOPY" >&6
8528 else
8529   echo "$as_me:$LINENO: result: no" >&5
8530 echo "${ECHO_T}no" >&6
8531 fi
8532
8533   done
8534 fi
8535
8536 for ncn_progname in objcopy; do
8537   if test -n "$ncn_tool_prefix"; then
8538     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8539 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8540 echo "$as_me:$LINENO: checking for $ac_word" >&5
8541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8542 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8543   echo $ECHO_N "(cached) $ECHO_C" >&6
8544 else
8545   if test -n "$OBJCOPY"; then
8546   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8547 else
8548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8549 for as_dir in $PATH
8550 do
8551   IFS=$as_save_IFS
8552   test -z "$as_dir" && as_dir=.
8553   for ac_exec_ext in '' $ac_executable_extensions; do
8554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8555     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8557     break 2
8558   fi
8559 done
8560 done
8561
8562 fi
8563 fi
8564 OBJCOPY=$ac_cv_prog_OBJCOPY
8565 if test -n "$OBJCOPY"; then
8566   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8567 echo "${ECHO_T}$OBJCOPY" >&6
8568 else
8569   echo "$as_me:$LINENO: result: no" >&5
8570 echo "${ECHO_T}no" >&6
8571 fi
8572
8573   fi
8574   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8575     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8576 set dummy ${ncn_progname}; ac_word=$2
8577 echo "$as_me:$LINENO: checking for $ac_word" >&5
8578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8579 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8580   echo $ECHO_N "(cached) $ECHO_C" >&6
8581 else
8582   if test -n "$OBJCOPY"; then
8583   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8584 else
8585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8586 for as_dir in $PATH
8587 do
8588   IFS=$as_save_IFS
8589   test -z "$as_dir" && as_dir=.
8590   for ac_exec_ext in '' $ac_executable_extensions; do
8591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8592     ac_cv_prog_OBJCOPY="${ncn_progname}"
8593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8594     break 2
8595   fi
8596 done
8597 done
8598
8599 fi
8600 fi
8601 OBJCOPY=$ac_cv_prog_OBJCOPY
8602 if test -n "$OBJCOPY"; then
8603   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8604 echo "${ECHO_T}$OBJCOPY" >&6
8605 else
8606   echo "$as_me:$LINENO: result: no" >&5
8607 echo "${ECHO_T}no" >&6
8608 fi
8609
8610   fi
8611   test -n "$ac_cv_prog_OBJCOPY" && break
8612 done
8613
8614 if test -z "$ac_cv_prog_OBJCOPY" ; then
8615   set dummy objcopy
8616   if test $build = $host ; then
8617     OBJCOPY="$2"
8618   else
8619     OBJCOPY="${ncn_tool_prefix}$2"
8620   fi
8621 fi
8622
8623
8624
8625 if test -n "$OBJDUMP"; then
8626   ac_cv_prog_OBJDUMP=$OBJDUMP
8627 elif test -n "$ac_cv_prog_OBJDUMP"; then
8628   OBJDUMP=$ac_cv_prog_OBJDUMP
8629 fi
8630
8631 if test -n "$ac_cv_prog_OBJDUMP"; then
8632   for ncn_progname in objdump; do
8633     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8634 set dummy ${ncn_progname}; ac_word=$2
8635 echo "$as_me:$LINENO: checking for $ac_word" >&5
8636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8637 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8638   echo $ECHO_N "(cached) $ECHO_C" >&6
8639 else
8640   if test -n "$OBJDUMP"; then
8641   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8642 else
8643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8644 for as_dir in $PATH
8645 do
8646   IFS=$as_save_IFS
8647   test -z "$as_dir" && as_dir=.
8648   for ac_exec_ext in '' $ac_executable_extensions; do
8649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8650     ac_cv_prog_OBJDUMP="${ncn_progname}"
8651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8652     break 2
8653   fi
8654 done
8655 done
8656
8657 fi
8658 fi
8659 OBJDUMP=$ac_cv_prog_OBJDUMP
8660 if test -n "$OBJDUMP"; then
8661   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8662 echo "${ECHO_T}$OBJDUMP" >&6
8663 else
8664   echo "$as_me:$LINENO: result: no" >&5
8665 echo "${ECHO_T}no" >&6
8666 fi
8667
8668   done
8669 fi
8670
8671 for ncn_progname in objdump; do
8672   if test -n "$ncn_tool_prefix"; then
8673     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8674 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8675 echo "$as_me:$LINENO: checking for $ac_word" >&5
8676 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8677 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8678   echo $ECHO_N "(cached) $ECHO_C" >&6
8679 else
8680   if test -n "$OBJDUMP"; then
8681   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8682 else
8683 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8684 for as_dir in $PATH
8685 do
8686   IFS=$as_save_IFS
8687   test -z "$as_dir" && as_dir=.
8688   for ac_exec_ext in '' $ac_executable_extensions; do
8689   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8690     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8691     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8692     break 2
8693   fi
8694 done
8695 done
8696
8697 fi
8698 fi
8699 OBJDUMP=$ac_cv_prog_OBJDUMP
8700 if test -n "$OBJDUMP"; then
8701   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8702 echo "${ECHO_T}$OBJDUMP" >&6
8703 else
8704   echo "$as_me:$LINENO: result: no" >&5
8705 echo "${ECHO_T}no" >&6
8706 fi
8707
8708   fi
8709   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8710     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8711 set dummy ${ncn_progname}; ac_word=$2
8712 echo "$as_me:$LINENO: checking for $ac_word" >&5
8713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8714 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8715   echo $ECHO_N "(cached) $ECHO_C" >&6
8716 else
8717   if test -n "$OBJDUMP"; then
8718   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8719 else
8720 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8721 for as_dir in $PATH
8722 do
8723   IFS=$as_save_IFS
8724   test -z "$as_dir" && as_dir=.
8725   for ac_exec_ext in '' $ac_executable_extensions; do
8726   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8727     ac_cv_prog_OBJDUMP="${ncn_progname}"
8728     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8729     break 2
8730   fi
8731 done
8732 done
8733
8734 fi
8735 fi
8736 OBJDUMP=$ac_cv_prog_OBJDUMP
8737 if test -n "$OBJDUMP"; then
8738   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8739 echo "${ECHO_T}$OBJDUMP" >&6
8740 else
8741   echo "$as_me:$LINENO: result: no" >&5
8742 echo "${ECHO_T}no" >&6
8743 fi
8744
8745   fi
8746   test -n "$ac_cv_prog_OBJDUMP" && break
8747 done
8748
8749 if test -z "$ac_cv_prog_OBJDUMP" ; then
8750   set dummy objdump
8751   if test $build = $host ; then
8752     OBJDUMP="$2"
8753   else
8754     OBJDUMP="${ncn_tool_prefix}$2"
8755   fi
8756 fi
8757
8758
8759
8760
8761
8762
8763 # Target tools.
8764
8765 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8766 if test "${with_build_time_tools+set}" = set; then
8767   withval="$with_build_time_tools"
8768   case x"$withval" in
8769      x/*) ;;
8770      *)
8771        with_build_time_tools=
8772        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8773 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8774        ;;
8775    esac
8776 else
8777   with_build_time_tools=
8778 fi;
8779
8780
8781
8782 if test -n "$CC_FOR_TARGET"; then
8783   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8784 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8785   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8786 fi
8787
8788 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8789   for ncn_progname in cc gcc; do
8790     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8791 set dummy ${ncn_progname}; ac_word=$2
8792 echo "$as_me:$LINENO: checking for $ac_word" >&5
8793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8794 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8795   echo $ECHO_N "(cached) $ECHO_C" >&6
8796 else
8797   if test -n "$CC_FOR_TARGET"; then
8798   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8799 else
8800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8801 for as_dir in $PATH
8802 do
8803   IFS=$as_save_IFS
8804   test -z "$as_dir" && as_dir=.
8805   for ac_exec_ext in '' $ac_executable_extensions; do
8806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8807     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8809     break 2
8810   fi
8811 done
8812 done
8813
8814 fi
8815 fi
8816 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8817 if test -n "$CC_FOR_TARGET"; then
8818   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8819 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8820 else
8821   echo "$as_me:$LINENO: result: no" >&5
8822 echo "${ECHO_T}no" >&6
8823 fi
8824
8825   done
8826 fi
8827
8828 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8829   for ncn_progname in cc gcc; do
8830     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8831 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8832     if test -x $with_build_time_tools/${ncn_progname}; then
8833       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8834       echo "$as_me:$LINENO: result: yes" >&5
8835 echo "${ECHO_T}yes" >&6
8836       break
8837     else
8838       echo "$as_me:$LINENO: result: no" >&5
8839 echo "${ECHO_T}no" >&6
8840     fi
8841   done
8842 fi
8843
8844 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8845   for ncn_progname in cc gcc; do
8846     if test -n "$ncn_target_tool_prefix"; then
8847       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8848 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8849 echo "$as_me:$LINENO: checking for $ac_word" >&5
8850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8851 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8852   echo $ECHO_N "(cached) $ECHO_C" >&6
8853 else
8854   if test -n "$CC_FOR_TARGET"; then
8855   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8856 else
8857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8858 for as_dir in $PATH
8859 do
8860   IFS=$as_save_IFS
8861   test -z "$as_dir" && as_dir=.
8862   for ac_exec_ext in '' $ac_executable_extensions; do
8863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8864     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8866     break 2
8867   fi
8868 done
8869 done
8870
8871 fi
8872 fi
8873 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8874 if test -n "$CC_FOR_TARGET"; then
8875   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8876 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8877 else
8878   echo "$as_me:$LINENO: result: no" >&5
8879 echo "${ECHO_T}no" >&6
8880 fi
8881
8882     fi
8883     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8884       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8885 set dummy ${ncn_progname}; ac_word=$2
8886 echo "$as_me:$LINENO: checking for $ac_word" >&5
8887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8888 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8889   echo $ECHO_N "(cached) $ECHO_C" >&6
8890 else
8891   if test -n "$CC_FOR_TARGET"; then
8892   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8893 else
8894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8895 for as_dir in $PATH
8896 do
8897   IFS=$as_save_IFS
8898   test -z "$as_dir" && as_dir=.
8899   for ac_exec_ext in '' $ac_executable_extensions; do
8900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8901     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8903     break 2
8904   fi
8905 done
8906 done
8907
8908 fi
8909 fi
8910 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8911 if test -n "$CC_FOR_TARGET"; then
8912   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8913 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8914 else
8915   echo "$as_me:$LINENO: result: no" >&5
8916 echo "${ECHO_T}no" >&6
8917 fi
8918
8919     fi
8920     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8921   done
8922 fi
8923
8924 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8925   set dummy cc gcc
8926   if test $build = $target ; then
8927     CC_FOR_TARGET="$2"
8928   else
8929     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8930   fi
8931 else
8932   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8933 fi
8934
8935
8936
8937 if test -n "$CXX_FOR_TARGET"; then
8938   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8939 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8940   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8941 fi
8942
8943 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8944   for ncn_progname in c++ g++ cxx gxx; do
8945     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8946 set dummy ${ncn_progname}; ac_word=$2
8947 echo "$as_me:$LINENO: checking for $ac_word" >&5
8948 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8949 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8950   echo $ECHO_N "(cached) $ECHO_C" >&6
8951 else
8952   if test -n "$CXX_FOR_TARGET"; then
8953   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8954 else
8955 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8956 for as_dir in $PATH
8957 do
8958   IFS=$as_save_IFS
8959   test -z "$as_dir" && as_dir=.
8960   for ac_exec_ext in '' $ac_executable_extensions; do
8961   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8962     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8963     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8964     break 2
8965   fi
8966 done
8967 done
8968
8969 fi
8970 fi
8971 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8972 if test -n "$CXX_FOR_TARGET"; then
8973   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8974 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8975 else
8976   echo "$as_me:$LINENO: result: no" >&5
8977 echo "${ECHO_T}no" >&6
8978 fi
8979
8980   done
8981 fi
8982
8983 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8984   for ncn_progname in c++ g++ cxx gxx; do
8985     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8986 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8987     if test -x $with_build_time_tools/${ncn_progname}; then
8988       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8989       echo "$as_me:$LINENO: result: yes" >&5
8990 echo "${ECHO_T}yes" >&6
8991       break
8992     else
8993       echo "$as_me:$LINENO: result: no" >&5
8994 echo "${ECHO_T}no" >&6
8995     fi
8996   done
8997 fi
8998
8999 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
9000   for ncn_progname in c++ g++ cxx gxx; do
9001     if test -n "$ncn_target_tool_prefix"; then
9002       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9003 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9004 echo "$as_me:$LINENO: checking for $ac_word" >&5
9005 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9006 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9007   echo $ECHO_N "(cached) $ECHO_C" >&6
9008 else
9009   if test -n "$CXX_FOR_TARGET"; then
9010   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9011 else
9012 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9013 for as_dir in $PATH
9014 do
9015   IFS=$as_save_IFS
9016   test -z "$as_dir" && as_dir=.
9017   for ac_exec_ext in '' $ac_executable_extensions; do
9018   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9019     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9020     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9021     break 2
9022   fi
9023 done
9024 done
9025
9026 fi
9027 fi
9028 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9029 if test -n "$CXX_FOR_TARGET"; then
9030   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9031 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9032 else
9033   echo "$as_me:$LINENO: result: no" >&5
9034 echo "${ECHO_T}no" >&6
9035 fi
9036
9037     fi
9038     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
9039       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9040 set dummy ${ncn_progname}; ac_word=$2
9041 echo "$as_me:$LINENO: checking for $ac_word" >&5
9042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9043 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9044   echo $ECHO_N "(cached) $ECHO_C" >&6
9045 else
9046   if test -n "$CXX_FOR_TARGET"; then
9047   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9048 else
9049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9050 for as_dir in $PATH
9051 do
9052   IFS=$as_save_IFS
9053   test -z "$as_dir" && as_dir=.
9054   for ac_exec_ext in '' $ac_executable_extensions; do
9055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9056     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
9057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9058     break 2
9059   fi
9060 done
9061 done
9062
9063 fi
9064 fi
9065 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9066 if test -n "$CXX_FOR_TARGET"; then
9067   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9068 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9069 else
9070   echo "$as_me:$LINENO: result: no" >&5
9071 echo "${ECHO_T}no" >&6
9072 fi
9073
9074     fi
9075     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
9076   done
9077 fi
9078
9079 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
9080   set dummy c++ g++ cxx gxx
9081   if test $build = $target ; then
9082     CXX_FOR_TARGET="$2"
9083   else
9084     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
9085   fi
9086 else
9087   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
9088 fi
9089
9090
9091
9092 if test -n "$GCC_FOR_TARGET"; then
9093   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
9094 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9095   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9096 fi
9097
9098 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9099   for ncn_progname in gcc; do
9100     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9101 set dummy ${ncn_progname}; ac_word=$2
9102 echo "$as_me:$LINENO: checking for $ac_word" >&5
9103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9104 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9105   echo $ECHO_N "(cached) $ECHO_C" >&6
9106 else
9107   if test -n "$GCC_FOR_TARGET"; then
9108   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9109 else
9110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9111 for as_dir in $PATH
9112 do
9113   IFS=$as_save_IFS
9114   test -z "$as_dir" && as_dir=.
9115   for ac_exec_ext in '' $ac_executable_extensions; do
9116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9117     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9119     break 2
9120   fi
9121 done
9122 done
9123
9124 fi
9125 fi
9126 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9127 if test -n "$GCC_FOR_TARGET"; then
9128   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9129 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9130 else
9131   echo "$as_me:$LINENO: result: no" >&5
9132 echo "${ECHO_T}no" >&6
9133 fi
9134
9135   done
9136 fi
9137
9138 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9139   for ncn_progname in gcc; do
9140     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9141 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9142     if test -x $with_build_time_tools/${ncn_progname}; then
9143       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9144       echo "$as_me:$LINENO: result: yes" >&5
9145 echo "${ECHO_T}yes" >&6
9146       break
9147     else
9148       echo "$as_me:$LINENO: result: no" >&5
9149 echo "${ECHO_T}no" >&6
9150     fi
9151   done
9152 fi
9153
9154 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9155   for ncn_progname in gcc; do
9156     if test -n "$ncn_target_tool_prefix"; then
9157       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9158 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9159 echo "$as_me:$LINENO: checking for $ac_word" >&5
9160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9161 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9162   echo $ECHO_N "(cached) $ECHO_C" >&6
9163 else
9164   if test -n "$GCC_FOR_TARGET"; then
9165   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9166 else
9167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9168 for as_dir in $PATH
9169 do
9170   IFS=$as_save_IFS
9171   test -z "$as_dir" && as_dir=.
9172   for ac_exec_ext in '' $ac_executable_extensions; do
9173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9174     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9176     break 2
9177   fi
9178 done
9179 done
9180
9181 fi
9182 fi
9183 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9184 if test -n "$GCC_FOR_TARGET"; then
9185   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9186 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9187 else
9188   echo "$as_me:$LINENO: result: no" >&5
9189 echo "${ECHO_T}no" >&6
9190 fi
9191
9192     fi
9193     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9194       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9195 set dummy ${ncn_progname}; ac_word=$2
9196 echo "$as_me:$LINENO: checking for $ac_word" >&5
9197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9198 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9199   echo $ECHO_N "(cached) $ECHO_C" >&6
9200 else
9201   if test -n "$GCC_FOR_TARGET"; then
9202   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9203 else
9204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9205 for as_dir in $PATH
9206 do
9207   IFS=$as_save_IFS
9208   test -z "$as_dir" && as_dir=.
9209   for ac_exec_ext in '' $ac_executable_extensions; do
9210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9211     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9213     break 2
9214   fi
9215 done
9216 done
9217
9218 fi
9219 fi
9220 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9221 if test -n "$GCC_FOR_TARGET"; then
9222   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9223 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9224 else
9225   echo "$as_me:$LINENO: result: no" >&5
9226 echo "${ECHO_T}no" >&6
9227 fi
9228
9229     fi
9230     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9231   done
9232 fi
9233
9234 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9235   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9236 else
9237   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9238 fi
9239
9240
9241
9242 if test -n "$GCJ_FOR_TARGET"; then
9243   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9244 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9245   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9246 fi
9247
9248 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9249   for ncn_progname in gcj; do
9250     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9251 set dummy ${ncn_progname}; ac_word=$2
9252 echo "$as_me:$LINENO: checking for $ac_word" >&5
9253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9254 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9255   echo $ECHO_N "(cached) $ECHO_C" >&6
9256 else
9257   if test -n "$GCJ_FOR_TARGET"; then
9258   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9259 else
9260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9261 for as_dir in $PATH
9262 do
9263   IFS=$as_save_IFS
9264   test -z "$as_dir" && as_dir=.
9265   for ac_exec_ext in '' $ac_executable_extensions; do
9266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9267     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9269     break 2
9270   fi
9271 done
9272 done
9273
9274 fi
9275 fi
9276 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9277 if test -n "$GCJ_FOR_TARGET"; then
9278   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9279 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9280 else
9281   echo "$as_me:$LINENO: result: no" >&5
9282 echo "${ECHO_T}no" >&6
9283 fi
9284
9285   done
9286 fi
9287
9288 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9289   for ncn_progname in gcj; do
9290     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9291 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9292     if test -x $with_build_time_tools/${ncn_progname}; then
9293       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9294       echo "$as_me:$LINENO: result: yes" >&5
9295 echo "${ECHO_T}yes" >&6
9296       break
9297     else
9298       echo "$as_me:$LINENO: result: no" >&5
9299 echo "${ECHO_T}no" >&6
9300     fi
9301   done
9302 fi
9303
9304 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9305   for ncn_progname in gcj; do
9306     if test -n "$ncn_target_tool_prefix"; then
9307       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9308 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9309 echo "$as_me:$LINENO: checking for $ac_word" >&5
9310 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9311 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9312   echo $ECHO_N "(cached) $ECHO_C" >&6
9313 else
9314   if test -n "$GCJ_FOR_TARGET"; then
9315   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9316 else
9317 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9318 for as_dir in $PATH
9319 do
9320   IFS=$as_save_IFS
9321   test -z "$as_dir" && as_dir=.
9322   for ac_exec_ext in '' $ac_executable_extensions; do
9323   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9324     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9325     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9326     break 2
9327   fi
9328 done
9329 done
9330
9331 fi
9332 fi
9333 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9334 if test -n "$GCJ_FOR_TARGET"; then
9335   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9336 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9337 else
9338   echo "$as_me:$LINENO: result: no" >&5
9339 echo "${ECHO_T}no" >&6
9340 fi
9341
9342     fi
9343     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9344       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9345 set dummy ${ncn_progname}; ac_word=$2
9346 echo "$as_me:$LINENO: checking for $ac_word" >&5
9347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9348 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9349   echo $ECHO_N "(cached) $ECHO_C" >&6
9350 else
9351   if test -n "$GCJ_FOR_TARGET"; then
9352   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9353 else
9354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9355 for as_dir in $PATH
9356 do
9357   IFS=$as_save_IFS
9358   test -z "$as_dir" && as_dir=.
9359   for ac_exec_ext in '' $ac_executable_extensions; do
9360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9361     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9363     break 2
9364   fi
9365 done
9366 done
9367
9368 fi
9369 fi
9370 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9371 if test -n "$GCJ_FOR_TARGET"; then
9372   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9373 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9374 else
9375   echo "$as_me:$LINENO: result: no" >&5
9376 echo "${ECHO_T}no" >&6
9377 fi
9378
9379     fi
9380     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9381   done
9382 fi
9383
9384 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9385   set dummy gcj
9386   if test $build = $target ; then
9387     GCJ_FOR_TARGET="$2"
9388   else
9389     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9390   fi
9391 else
9392   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9393 fi
9394
9395
9396
9397 if test -n "$GFORTRAN_FOR_TARGET"; then
9398   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9399 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9400   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9401 fi
9402
9403 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9404   for ncn_progname in gfortran; do
9405     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9406 set dummy ${ncn_progname}; ac_word=$2
9407 echo "$as_me:$LINENO: checking for $ac_word" >&5
9408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9409 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9410   echo $ECHO_N "(cached) $ECHO_C" >&6
9411 else
9412   if test -n "$GFORTRAN_FOR_TARGET"; then
9413   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9414 else
9415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9416 for as_dir in $PATH
9417 do
9418   IFS=$as_save_IFS
9419   test -z "$as_dir" && as_dir=.
9420   for ac_exec_ext in '' $ac_executable_extensions; do
9421   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9422     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9423     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9424     break 2
9425   fi
9426 done
9427 done
9428
9429 fi
9430 fi
9431 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9432 if test -n "$GFORTRAN_FOR_TARGET"; then
9433   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9434 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9435 else
9436   echo "$as_me:$LINENO: result: no" >&5
9437 echo "${ECHO_T}no" >&6
9438 fi
9439
9440   done
9441 fi
9442
9443 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9444   for ncn_progname in gfortran; do
9445     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9446 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9447     if test -x $with_build_time_tools/${ncn_progname}; then
9448       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9449       echo "$as_me:$LINENO: result: yes" >&5
9450 echo "${ECHO_T}yes" >&6
9451       break
9452     else
9453       echo "$as_me:$LINENO: result: no" >&5
9454 echo "${ECHO_T}no" >&6
9455     fi
9456   done
9457 fi
9458
9459 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9460   for ncn_progname in gfortran; do
9461     if test -n "$ncn_target_tool_prefix"; then
9462       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9463 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9464 echo "$as_me:$LINENO: checking for $ac_word" >&5
9465 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9466 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9467   echo $ECHO_N "(cached) $ECHO_C" >&6
9468 else
9469   if test -n "$GFORTRAN_FOR_TARGET"; then
9470   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9471 else
9472 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9473 for as_dir in $PATH
9474 do
9475   IFS=$as_save_IFS
9476   test -z "$as_dir" && as_dir=.
9477   for ac_exec_ext in '' $ac_executable_extensions; do
9478   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9479     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9480     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9481     break 2
9482   fi
9483 done
9484 done
9485
9486 fi
9487 fi
9488 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9489 if test -n "$GFORTRAN_FOR_TARGET"; then
9490   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9491 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9492 else
9493   echo "$as_me:$LINENO: result: no" >&5
9494 echo "${ECHO_T}no" >&6
9495 fi
9496
9497     fi
9498     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9499       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9500 set dummy ${ncn_progname}; ac_word=$2
9501 echo "$as_me:$LINENO: checking for $ac_word" >&5
9502 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9503 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9504   echo $ECHO_N "(cached) $ECHO_C" >&6
9505 else
9506   if test -n "$GFORTRAN_FOR_TARGET"; then
9507   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9508 else
9509 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9510 for as_dir in $PATH
9511 do
9512   IFS=$as_save_IFS
9513   test -z "$as_dir" && as_dir=.
9514   for ac_exec_ext in '' $ac_executable_extensions; do
9515   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9516     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9517     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9518     break 2
9519   fi
9520 done
9521 done
9522
9523 fi
9524 fi
9525 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9526 if test -n "$GFORTRAN_FOR_TARGET"; then
9527   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9528 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9529 else
9530   echo "$as_me:$LINENO: result: no" >&5
9531 echo "${ECHO_T}no" >&6
9532 fi
9533
9534     fi
9535     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9536   done
9537 fi
9538
9539 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9540   set dummy gfortran
9541   if test $build = $target ; then
9542     GFORTRAN_FOR_TARGET="$2"
9543   else
9544     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9545   fi
9546 else
9547   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9548 fi
9549
9550
9551
9552 cat > conftest.c << \EOF
9553 #ifdef __GNUC__
9554   gcc_yay;
9555 #endif
9556 EOF
9557 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9558   have_gcc_for_target=yes
9559 else
9560   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9561   have_gcc_for_target=no
9562 fi
9563 rm conftest.c
9564
9565
9566
9567
9568 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9569   if test -n "$with_build_time_tools"; then
9570     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9571 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9572     if test -x $with_build_time_tools/ar; then
9573       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9574       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9575       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9576 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9577     else
9578       echo "$as_me:$LINENO: result: no" >&5
9579 echo "${ECHO_T}no" >&6
9580     fi
9581   elif test $build != $host && test $have_gcc_for_target = yes; then
9582     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9583     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9584     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9585   fi
9586 fi
9587 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9588   # Extract the first word of "ar", so it can be a program name with args.
9589 set dummy ar; ac_word=$2
9590 echo "$as_me:$LINENO: checking for $ac_word" >&5
9591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9592 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9593   echo $ECHO_N "(cached) $ECHO_C" >&6
9594 else
9595   case $AR_FOR_TARGET in
9596   [\\/]* | ?:[\\/]*)
9597   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9598   ;;
9599   *)
9600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9601 for as_dir in $gcc_cv_tool_dirs
9602 do
9603   IFS=$as_save_IFS
9604   test -z "$as_dir" && as_dir=.
9605   for ac_exec_ext in '' $ac_executable_extensions; do
9606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9607     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9609     break 2
9610   fi
9611 done
9612 done
9613
9614   ;;
9615 esac
9616 fi
9617 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9618
9619 if test -n "$AR_FOR_TARGET"; then
9620   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9621 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9622 else
9623   echo "$as_me:$LINENO: result: no" >&5
9624 echo "${ECHO_T}no" >&6
9625 fi
9626
9627 fi
9628 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9629
9630
9631 if test -n "$AR_FOR_TARGET"; then
9632   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9633 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9634   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9635 fi
9636
9637 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9638   for ncn_progname in ar; do
9639     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9640 set dummy ${ncn_progname}; ac_word=$2
9641 echo "$as_me:$LINENO: checking for $ac_word" >&5
9642 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9643 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9644   echo $ECHO_N "(cached) $ECHO_C" >&6
9645 else
9646   if test -n "$AR_FOR_TARGET"; then
9647   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9648 else
9649 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9650 for as_dir in $PATH
9651 do
9652   IFS=$as_save_IFS
9653   test -z "$as_dir" && as_dir=.
9654   for ac_exec_ext in '' $ac_executable_extensions; do
9655   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9656     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9657     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9658     break 2
9659   fi
9660 done
9661 done
9662
9663 fi
9664 fi
9665 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9666 if test -n "$AR_FOR_TARGET"; then
9667   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9668 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9669 else
9670   echo "$as_me:$LINENO: result: no" >&5
9671 echo "${ECHO_T}no" >&6
9672 fi
9673
9674   done
9675 fi
9676
9677 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9678   for ncn_progname in ar; do
9679     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9680 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9681     if test -x $with_build_time_tools/${ncn_progname}; then
9682       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9683       echo "$as_me:$LINENO: result: yes" >&5
9684 echo "${ECHO_T}yes" >&6
9685       break
9686     else
9687       echo "$as_me:$LINENO: result: no" >&5
9688 echo "${ECHO_T}no" >&6
9689     fi
9690   done
9691 fi
9692
9693 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9694   for ncn_progname in ar; do
9695     if test -n "$ncn_target_tool_prefix"; then
9696       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9697 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9698 echo "$as_me:$LINENO: checking for $ac_word" >&5
9699 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9700 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9701   echo $ECHO_N "(cached) $ECHO_C" >&6
9702 else
9703   if test -n "$AR_FOR_TARGET"; then
9704   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9705 else
9706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9707 for as_dir in $PATH
9708 do
9709   IFS=$as_save_IFS
9710   test -z "$as_dir" && as_dir=.
9711   for ac_exec_ext in '' $ac_executable_extensions; do
9712   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9713     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9714     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9715     break 2
9716   fi
9717 done
9718 done
9719
9720 fi
9721 fi
9722 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9723 if test -n "$AR_FOR_TARGET"; then
9724   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9725 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9726 else
9727   echo "$as_me:$LINENO: result: no" >&5
9728 echo "${ECHO_T}no" >&6
9729 fi
9730
9731     fi
9732     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9733       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9734 set dummy ${ncn_progname}; ac_word=$2
9735 echo "$as_me:$LINENO: checking for $ac_word" >&5
9736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9737 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9738   echo $ECHO_N "(cached) $ECHO_C" >&6
9739 else
9740   if test -n "$AR_FOR_TARGET"; then
9741   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9742 else
9743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9744 for as_dir in $PATH
9745 do
9746   IFS=$as_save_IFS
9747   test -z "$as_dir" && as_dir=.
9748   for ac_exec_ext in '' $ac_executable_extensions; do
9749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9750     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9752     break 2
9753   fi
9754 done
9755 done
9756
9757 fi
9758 fi
9759 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9760 if test -n "$AR_FOR_TARGET"; then
9761   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9762 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9763 else
9764   echo "$as_me:$LINENO: result: no" >&5
9765 echo "${ECHO_T}no" >&6
9766 fi
9767
9768     fi
9769     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9770   done
9771 fi
9772
9773 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9774   set dummy ar
9775   if test $build = $target ; then
9776     AR_FOR_TARGET="$2"
9777   else
9778     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9779   fi
9780 else
9781   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9782 fi
9783
9784 else
9785   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9786 fi
9787
9788
9789
9790
9791 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9792   if test -n "$with_build_time_tools"; then
9793     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9794 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9795     if test -x $with_build_time_tools/as; then
9796       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9797       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9798       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9799 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9800     else
9801       echo "$as_me:$LINENO: result: no" >&5
9802 echo "${ECHO_T}no" >&6
9803     fi
9804   elif test $build != $host && test $have_gcc_for_target = yes; then
9805     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9806     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9807     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9808   fi
9809 fi
9810 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9811   # Extract the first word of "as", so it can be a program name with args.
9812 set dummy as; ac_word=$2
9813 echo "$as_me:$LINENO: checking for $ac_word" >&5
9814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9815 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9816   echo $ECHO_N "(cached) $ECHO_C" >&6
9817 else
9818   case $AS_FOR_TARGET in
9819   [\\/]* | ?:[\\/]*)
9820   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9821   ;;
9822   *)
9823   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9824 for as_dir in $gcc_cv_tool_dirs
9825 do
9826   IFS=$as_save_IFS
9827   test -z "$as_dir" && as_dir=.
9828   for ac_exec_ext in '' $ac_executable_extensions; do
9829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9830     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9832     break 2
9833   fi
9834 done
9835 done
9836
9837   ;;
9838 esac
9839 fi
9840 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9841
9842 if test -n "$AS_FOR_TARGET"; then
9843   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9844 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9845 else
9846   echo "$as_me:$LINENO: result: no" >&5
9847 echo "${ECHO_T}no" >&6
9848 fi
9849
9850 fi
9851 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9852
9853
9854 if test -n "$AS_FOR_TARGET"; then
9855   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9856 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9857   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9858 fi
9859
9860 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9861   for ncn_progname in as; do
9862     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9863 set dummy ${ncn_progname}; ac_word=$2
9864 echo "$as_me:$LINENO: checking for $ac_word" >&5
9865 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9866 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9867   echo $ECHO_N "(cached) $ECHO_C" >&6
9868 else
9869   if test -n "$AS_FOR_TARGET"; then
9870   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9871 else
9872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9873 for as_dir in $PATH
9874 do
9875   IFS=$as_save_IFS
9876   test -z "$as_dir" && as_dir=.
9877   for ac_exec_ext in '' $ac_executable_extensions; do
9878   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9879     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9880     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9881     break 2
9882   fi
9883 done
9884 done
9885
9886 fi
9887 fi
9888 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9889 if test -n "$AS_FOR_TARGET"; then
9890   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9891 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9892 else
9893   echo "$as_me:$LINENO: result: no" >&5
9894 echo "${ECHO_T}no" >&6
9895 fi
9896
9897   done
9898 fi
9899
9900 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9901   for ncn_progname in as; do
9902     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9903 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9904     if test -x $with_build_time_tools/${ncn_progname}; then
9905       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9906       echo "$as_me:$LINENO: result: yes" >&5
9907 echo "${ECHO_T}yes" >&6
9908       break
9909     else
9910       echo "$as_me:$LINENO: result: no" >&5
9911 echo "${ECHO_T}no" >&6
9912     fi
9913   done
9914 fi
9915
9916 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9917   for ncn_progname in as; do
9918     if test -n "$ncn_target_tool_prefix"; then
9919       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9920 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9921 echo "$as_me:$LINENO: checking for $ac_word" >&5
9922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9923 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9924   echo $ECHO_N "(cached) $ECHO_C" >&6
9925 else
9926   if test -n "$AS_FOR_TARGET"; then
9927   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9928 else
9929 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9930 for as_dir in $PATH
9931 do
9932   IFS=$as_save_IFS
9933   test -z "$as_dir" && as_dir=.
9934   for ac_exec_ext in '' $ac_executable_extensions; do
9935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9936     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9938     break 2
9939   fi
9940 done
9941 done
9942
9943 fi
9944 fi
9945 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9946 if test -n "$AS_FOR_TARGET"; then
9947   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9948 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9949 else
9950   echo "$as_me:$LINENO: result: no" >&5
9951 echo "${ECHO_T}no" >&6
9952 fi
9953
9954     fi
9955     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9956       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9957 set dummy ${ncn_progname}; ac_word=$2
9958 echo "$as_me:$LINENO: checking for $ac_word" >&5
9959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9960 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9961   echo $ECHO_N "(cached) $ECHO_C" >&6
9962 else
9963   if test -n "$AS_FOR_TARGET"; then
9964   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9965 else
9966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9967 for as_dir in $PATH
9968 do
9969   IFS=$as_save_IFS
9970   test -z "$as_dir" && as_dir=.
9971   for ac_exec_ext in '' $ac_executable_extensions; do
9972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9973     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9975     break 2
9976   fi
9977 done
9978 done
9979
9980 fi
9981 fi
9982 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9983 if test -n "$AS_FOR_TARGET"; then
9984   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9985 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9986 else
9987   echo "$as_me:$LINENO: result: no" >&5
9988 echo "${ECHO_T}no" >&6
9989 fi
9990
9991     fi
9992     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9993   done
9994 fi
9995
9996 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9997   set dummy as
9998   if test $build = $target ; then
9999     AS_FOR_TARGET="$2"
10000   else
10001     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
10002   fi
10003 else
10004   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
10005 fi
10006
10007 else
10008   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
10009 fi
10010
10011
10012
10013
10014 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10015   if test -n "$with_build_time_tools"; then
10016     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
10017 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
10018     if test -x $with_build_time_tools/dlltool; then
10019       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
10020       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10021       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
10022 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
10023     else
10024       echo "$as_me:$LINENO: result: no" >&5
10025 echo "${ECHO_T}no" >&6
10026     fi
10027   elif test $build != $host && test $have_gcc_for_target = yes; then
10028     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
10029     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
10030     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10031   fi
10032 fi
10033 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10034   # Extract the first word of "dlltool", so it can be a program name with args.
10035 set dummy dlltool; ac_word=$2
10036 echo "$as_me:$LINENO: checking for $ac_word" >&5
10037 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10038 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
10039   echo $ECHO_N "(cached) $ECHO_C" >&6
10040 else
10041   case $DLLTOOL_FOR_TARGET in
10042   [\\/]* | ?:[\\/]*)
10043   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
10044   ;;
10045   *)
10046   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10047 for as_dir in $gcc_cv_tool_dirs
10048 do
10049   IFS=$as_save_IFS
10050   test -z "$as_dir" && as_dir=.
10051   for ac_exec_ext in '' $ac_executable_extensions; do
10052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10053     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10055     break 2
10056   fi
10057 done
10058 done
10059
10060   ;;
10061 esac
10062 fi
10063 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10064
10065 if test -n "$DLLTOOL_FOR_TARGET"; then
10066   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10067 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10068 else
10069   echo "$as_me:$LINENO: result: no" >&5
10070 echo "${ECHO_T}no" >&6
10071 fi
10072
10073 fi
10074 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10075
10076
10077 if test -n "$DLLTOOL_FOR_TARGET"; then
10078   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10079 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10080   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10081 fi
10082
10083 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10084   for ncn_progname in dlltool; do
10085     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10086 set dummy ${ncn_progname}; ac_word=$2
10087 echo "$as_me:$LINENO: checking for $ac_word" >&5
10088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10089 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10090   echo $ECHO_N "(cached) $ECHO_C" >&6
10091 else
10092   if test -n "$DLLTOOL_FOR_TARGET"; then
10093   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10094 else
10095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10096 for as_dir in $PATH
10097 do
10098   IFS=$as_save_IFS
10099   test -z "$as_dir" && as_dir=.
10100   for ac_exec_ext in '' $ac_executable_extensions; do
10101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10102     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10104     break 2
10105   fi
10106 done
10107 done
10108
10109 fi
10110 fi
10111 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10112 if test -n "$DLLTOOL_FOR_TARGET"; then
10113   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10114 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10115 else
10116   echo "$as_me:$LINENO: result: no" >&5
10117 echo "${ECHO_T}no" >&6
10118 fi
10119
10120   done
10121 fi
10122
10123 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10124   for ncn_progname in dlltool; do
10125     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10126 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10127     if test -x $with_build_time_tools/${ncn_progname}; then
10128       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10129       echo "$as_me:$LINENO: result: yes" >&5
10130 echo "${ECHO_T}yes" >&6
10131       break
10132     else
10133       echo "$as_me:$LINENO: result: no" >&5
10134 echo "${ECHO_T}no" >&6
10135     fi
10136   done
10137 fi
10138
10139 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10140   for ncn_progname in dlltool; do
10141     if test -n "$ncn_target_tool_prefix"; then
10142       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10143 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10144 echo "$as_me:$LINENO: checking for $ac_word" >&5
10145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10146 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10147   echo $ECHO_N "(cached) $ECHO_C" >&6
10148 else
10149   if test -n "$DLLTOOL_FOR_TARGET"; then
10150   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10151 else
10152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10153 for as_dir in $PATH
10154 do
10155   IFS=$as_save_IFS
10156   test -z "$as_dir" && as_dir=.
10157   for ac_exec_ext in '' $ac_executable_extensions; do
10158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10159     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10161     break 2
10162   fi
10163 done
10164 done
10165
10166 fi
10167 fi
10168 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10169 if test -n "$DLLTOOL_FOR_TARGET"; then
10170   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10171 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10172 else
10173   echo "$as_me:$LINENO: result: no" >&5
10174 echo "${ECHO_T}no" >&6
10175 fi
10176
10177     fi
10178     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10179       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10180 set dummy ${ncn_progname}; ac_word=$2
10181 echo "$as_me:$LINENO: checking for $ac_word" >&5
10182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10183 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10184   echo $ECHO_N "(cached) $ECHO_C" >&6
10185 else
10186   if test -n "$DLLTOOL_FOR_TARGET"; then
10187   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10188 else
10189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10190 for as_dir in $PATH
10191 do
10192   IFS=$as_save_IFS
10193   test -z "$as_dir" && as_dir=.
10194   for ac_exec_ext in '' $ac_executable_extensions; do
10195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10196     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10198     break 2
10199   fi
10200 done
10201 done
10202
10203 fi
10204 fi
10205 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10206 if test -n "$DLLTOOL_FOR_TARGET"; then
10207   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10208 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10209 else
10210   echo "$as_me:$LINENO: result: no" >&5
10211 echo "${ECHO_T}no" >&6
10212 fi
10213
10214     fi
10215     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10216   done
10217 fi
10218
10219 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10220   set dummy dlltool
10221   if test $build = $target ; then
10222     DLLTOOL_FOR_TARGET="$2"
10223   else
10224     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10225   fi
10226 else
10227   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10228 fi
10229
10230 else
10231   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10232 fi
10233
10234
10235
10236
10237 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10238   if test -n "$with_build_time_tools"; then
10239     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10240 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10241     if test -x $with_build_time_tools/ld; then
10242       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10243       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10244       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10245 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10246     else
10247       echo "$as_me:$LINENO: result: no" >&5
10248 echo "${ECHO_T}no" >&6
10249     fi
10250   elif test $build != $host && test $have_gcc_for_target = yes; then
10251     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10252     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10253     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10254   fi
10255 fi
10256 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10257   # Extract the first word of "ld", so it can be a program name with args.
10258 set dummy ld; ac_word=$2
10259 echo "$as_me:$LINENO: checking for $ac_word" >&5
10260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10261 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10262   echo $ECHO_N "(cached) $ECHO_C" >&6
10263 else
10264   case $LD_FOR_TARGET in
10265   [\\/]* | ?:[\\/]*)
10266   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10267   ;;
10268   *)
10269   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10270 for as_dir in $gcc_cv_tool_dirs
10271 do
10272   IFS=$as_save_IFS
10273   test -z "$as_dir" && as_dir=.
10274   for ac_exec_ext in '' $ac_executable_extensions; do
10275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10276     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10278     break 2
10279   fi
10280 done
10281 done
10282
10283   ;;
10284 esac
10285 fi
10286 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10287
10288 if test -n "$LD_FOR_TARGET"; then
10289   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10290 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10291 else
10292   echo "$as_me:$LINENO: result: no" >&5
10293 echo "${ECHO_T}no" >&6
10294 fi
10295
10296 fi
10297 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10298
10299
10300 if test -n "$LD_FOR_TARGET"; then
10301   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10302 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10303   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10304 fi
10305
10306 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10307   for ncn_progname in ld; do
10308     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10309 set dummy ${ncn_progname}; ac_word=$2
10310 echo "$as_me:$LINENO: checking for $ac_word" >&5
10311 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10312 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10313   echo $ECHO_N "(cached) $ECHO_C" >&6
10314 else
10315   if test -n "$LD_FOR_TARGET"; then
10316   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10317 else
10318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10319 for as_dir in $PATH
10320 do
10321   IFS=$as_save_IFS
10322   test -z "$as_dir" && as_dir=.
10323   for ac_exec_ext in '' $ac_executable_extensions; do
10324   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10325     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10326     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10327     break 2
10328   fi
10329 done
10330 done
10331
10332 fi
10333 fi
10334 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10335 if test -n "$LD_FOR_TARGET"; then
10336   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10337 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10338 else
10339   echo "$as_me:$LINENO: result: no" >&5
10340 echo "${ECHO_T}no" >&6
10341 fi
10342
10343   done
10344 fi
10345
10346 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10347   for ncn_progname in ld; do
10348     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10349 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10350     if test -x $with_build_time_tools/${ncn_progname}; then
10351       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10352       echo "$as_me:$LINENO: result: yes" >&5
10353 echo "${ECHO_T}yes" >&6
10354       break
10355     else
10356       echo "$as_me:$LINENO: result: no" >&5
10357 echo "${ECHO_T}no" >&6
10358     fi
10359   done
10360 fi
10361
10362 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10363   for ncn_progname in ld; do
10364     if test -n "$ncn_target_tool_prefix"; then
10365       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10366 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10367 echo "$as_me:$LINENO: checking for $ac_word" >&5
10368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10369 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10370   echo $ECHO_N "(cached) $ECHO_C" >&6
10371 else
10372   if test -n "$LD_FOR_TARGET"; then
10373   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10374 else
10375 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10376 for as_dir in $PATH
10377 do
10378   IFS=$as_save_IFS
10379   test -z "$as_dir" && as_dir=.
10380   for ac_exec_ext in '' $ac_executable_extensions; do
10381   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10382     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10383     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10384     break 2
10385   fi
10386 done
10387 done
10388
10389 fi
10390 fi
10391 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10392 if test -n "$LD_FOR_TARGET"; then
10393   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10394 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10395 else
10396   echo "$as_me:$LINENO: result: no" >&5
10397 echo "${ECHO_T}no" >&6
10398 fi
10399
10400     fi
10401     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10402       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10403 set dummy ${ncn_progname}; ac_word=$2
10404 echo "$as_me:$LINENO: checking for $ac_word" >&5
10405 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10406 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10407   echo $ECHO_N "(cached) $ECHO_C" >&6
10408 else
10409   if test -n "$LD_FOR_TARGET"; then
10410   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10411 else
10412 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10413 for as_dir in $PATH
10414 do
10415   IFS=$as_save_IFS
10416   test -z "$as_dir" && as_dir=.
10417   for ac_exec_ext in '' $ac_executable_extensions; do
10418   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10419     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10420     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10421     break 2
10422   fi
10423 done
10424 done
10425
10426 fi
10427 fi
10428 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10429 if test -n "$LD_FOR_TARGET"; then
10430   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10431 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10432 else
10433   echo "$as_me:$LINENO: result: no" >&5
10434 echo "${ECHO_T}no" >&6
10435 fi
10436
10437     fi
10438     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10439   done
10440 fi
10441
10442 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10443   set dummy ld
10444   if test $build = $target ; then
10445     LD_FOR_TARGET="$2"
10446   else
10447     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10448   fi
10449 else
10450   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10451 fi
10452
10453 else
10454   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10455 fi
10456
10457
10458
10459
10460 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10461   if test -n "$with_build_time_tools"; then
10462     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10463 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10464     if test -x $with_build_time_tools/lipo; then
10465       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10466       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10467       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10468 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10469     else
10470       echo "$as_me:$LINENO: result: no" >&5
10471 echo "${ECHO_T}no" >&6
10472     fi
10473   elif test $build != $host && test $have_gcc_for_target = yes; then
10474     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10475     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10476     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10477   fi
10478 fi
10479 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10480   # Extract the first word of "lipo", so it can be a program name with args.
10481 set dummy lipo; ac_word=$2
10482 echo "$as_me:$LINENO: checking for $ac_word" >&5
10483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10484 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10485   echo $ECHO_N "(cached) $ECHO_C" >&6
10486 else
10487   case $LIPO_FOR_TARGET in
10488   [\\/]* | ?:[\\/]*)
10489   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10490   ;;
10491   *)
10492   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10493 for as_dir in $gcc_cv_tool_dirs
10494 do
10495   IFS=$as_save_IFS
10496   test -z "$as_dir" && as_dir=.
10497   for ac_exec_ext in '' $ac_executable_extensions; do
10498   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10499     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10500     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10501     break 2
10502   fi
10503 done
10504 done
10505
10506   ;;
10507 esac
10508 fi
10509 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10510
10511 if test -n "$LIPO_FOR_TARGET"; then
10512   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10513 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10514 else
10515   echo "$as_me:$LINENO: result: no" >&5
10516 echo "${ECHO_T}no" >&6
10517 fi
10518
10519 fi
10520 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10521
10522
10523 if test -n "$LIPO_FOR_TARGET"; then
10524   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10525 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10526   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10527 fi
10528
10529 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10530   for ncn_progname in lipo; do
10531     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10532 set dummy ${ncn_progname}; ac_word=$2
10533 echo "$as_me:$LINENO: checking for $ac_word" >&5
10534 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10535 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10536   echo $ECHO_N "(cached) $ECHO_C" >&6
10537 else
10538   if test -n "$LIPO_FOR_TARGET"; then
10539   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10540 else
10541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10542 for as_dir in $PATH
10543 do
10544   IFS=$as_save_IFS
10545   test -z "$as_dir" && as_dir=.
10546   for ac_exec_ext in '' $ac_executable_extensions; do
10547   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10548     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10549     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10550     break 2
10551   fi
10552 done
10553 done
10554
10555 fi
10556 fi
10557 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10558 if test -n "$LIPO_FOR_TARGET"; then
10559   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10560 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10561 else
10562   echo "$as_me:$LINENO: result: no" >&5
10563 echo "${ECHO_T}no" >&6
10564 fi
10565
10566   done
10567 fi
10568
10569 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10570   for ncn_progname in lipo; do
10571     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10572 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10573     if test -x $with_build_time_tools/${ncn_progname}; then
10574       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10575       echo "$as_me:$LINENO: result: yes" >&5
10576 echo "${ECHO_T}yes" >&6
10577       break
10578     else
10579       echo "$as_me:$LINENO: result: no" >&5
10580 echo "${ECHO_T}no" >&6
10581     fi
10582   done
10583 fi
10584
10585 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10586   for ncn_progname in lipo; do
10587     if test -n "$ncn_target_tool_prefix"; then
10588       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10589 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10590 echo "$as_me:$LINENO: checking for $ac_word" >&5
10591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10592 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10593   echo $ECHO_N "(cached) $ECHO_C" >&6
10594 else
10595   if test -n "$LIPO_FOR_TARGET"; then
10596   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10597 else
10598 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10599 for as_dir in $PATH
10600 do
10601   IFS=$as_save_IFS
10602   test -z "$as_dir" && as_dir=.
10603   for ac_exec_ext in '' $ac_executable_extensions; do
10604   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10605     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10606     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10607     break 2
10608   fi
10609 done
10610 done
10611
10612 fi
10613 fi
10614 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10615 if test -n "$LIPO_FOR_TARGET"; then
10616   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10617 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10618 else
10619   echo "$as_me:$LINENO: result: no" >&5
10620 echo "${ECHO_T}no" >&6
10621 fi
10622
10623     fi
10624     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10625       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10626 set dummy ${ncn_progname}; ac_word=$2
10627 echo "$as_me:$LINENO: checking for $ac_word" >&5
10628 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10629 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10630   echo $ECHO_N "(cached) $ECHO_C" >&6
10631 else
10632   if test -n "$LIPO_FOR_TARGET"; then
10633   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10634 else
10635 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10636 for as_dir in $PATH
10637 do
10638   IFS=$as_save_IFS
10639   test -z "$as_dir" && as_dir=.
10640   for ac_exec_ext in '' $ac_executable_extensions; do
10641   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10642     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10643     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10644     break 2
10645   fi
10646 done
10647 done
10648
10649 fi
10650 fi
10651 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10652 if test -n "$LIPO_FOR_TARGET"; then
10653   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10654 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10655 else
10656   echo "$as_me:$LINENO: result: no" >&5
10657 echo "${ECHO_T}no" >&6
10658 fi
10659
10660     fi
10661     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10662   done
10663 fi
10664
10665 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10666   set dummy lipo
10667   if test $build = $target ; then
10668     LIPO_FOR_TARGET="$2"
10669   else
10670     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10671   fi
10672 else
10673   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10674 fi
10675
10676 else
10677   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10678 fi
10679
10680
10681
10682
10683 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10684   if test -n "$with_build_time_tools"; then
10685     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10686 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10687     if test -x $with_build_time_tools/nm; then
10688       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10689       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10690       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10691 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10692     else
10693       echo "$as_me:$LINENO: result: no" >&5
10694 echo "${ECHO_T}no" >&6
10695     fi
10696   elif test $build != $host && test $have_gcc_for_target = yes; then
10697     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10698     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10699     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10700   fi
10701 fi
10702 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10703   # Extract the first word of "nm", so it can be a program name with args.
10704 set dummy nm; ac_word=$2
10705 echo "$as_me:$LINENO: checking for $ac_word" >&5
10706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10707 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10708   echo $ECHO_N "(cached) $ECHO_C" >&6
10709 else
10710   case $NM_FOR_TARGET in
10711   [\\/]* | ?:[\\/]*)
10712   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10713   ;;
10714   *)
10715   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10716 for as_dir in $gcc_cv_tool_dirs
10717 do
10718   IFS=$as_save_IFS
10719   test -z "$as_dir" && as_dir=.
10720   for ac_exec_ext in '' $ac_executable_extensions; do
10721   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10722     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10723     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10724     break 2
10725   fi
10726 done
10727 done
10728
10729   ;;
10730 esac
10731 fi
10732 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10733
10734 if test -n "$NM_FOR_TARGET"; then
10735   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10736 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10737 else
10738   echo "$as_me:$LINENO: result: no" >&5
10739 echo "${ECHO_T}no" >&6
10740 fi
10741
10742 fi
10743 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10744
10745
10746 if test -n "$NM_FOR_TARGET"; then
10747   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10748 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10749   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10750 fi
10751
10752 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10753   for ncn_progname in nm; do
10754     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10755 set dummy ${ncn_progname}; ac_word=$2
10756 echo "$as_me:$LINENO: checking for $ac_word" >&5
10757 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10758 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10759   echo $ECHO_N "(cached) $ECHO_C" >&6
10760 else
10761   if test -n "$NM_FOR_TARGET"; then
10762   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10763 else
10764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10765 for as_dir in $PATH
10766 do
10767   IFS=$as_save_IFS
10768   test -z "$as_dir" && as_dir=.
10769   for ac_exec_ext in '' $ac_executable_extensions; do
10770   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10771     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10772     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10773     break 2
10774   fi
10775 done
10776 done
10777
10778 fi
10779 fi
10780 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10781 if test -n "$NM_FOR_TARGET"; then
10782   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10783 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10784 else
10785   echo "$as_me:$LINENO: result: no" >&5
10786 echo "${ECHO_T}no" >&6
10787 fi
10788
10789   done
10790 fi
10791
10792 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10793   for ncn_progname in nm; do
10794     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10795 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10796     if test -x $with_build_time_tools/${ncn_progname}; then
10797       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10798       echo "$as_me:$LINENO: result: yes" >&5
10799 echo "${ECHO_T}yes" >&6
10800       break
10801     else
10802       echo "$as_me:$LINENO: result: no" >&5
10803 echo "${ECHO_T}no" >&6
10804     fi
10805   done
10806 fi
10807
10808 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10809   for ncn_progname in nm; do
10810     if test -n "$ncn_target_tool_prefix"; then
10811       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10812 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10813 echo "$as_me:$LINENO: checking for $ac_word" >&5
10814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10815 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10816   echo $ECHO_N "(cached) $ECHO_C" >&6
10817 else
10818   if test -n "$NM_FOR_TARGET"; then
10819   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10820 else
10821 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10822 for as_dir in $PATH
10823 do
10824   IFS=$as_save_IFS
10825   test -z "$as_dir" && as_dir=.
10826   for ac_exec_ext in '' $ac_executable_extensions; do
10827   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10828     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10829     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10830     break 2
10831   fi
10832 done
10833 done
10834
10835 fi
10836 fi
10837 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10838 if test -n "$NM_FOR_TARGET"; then
10839   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10840 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10841 else
10842   echo "$as_me:$LINENO: result: no" >&5
10843 echo "${ECHO_T}no" >&6
10844 fi
10845
10846     fi
10847     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10848       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10849 set dummy ${ncn_progname}; ac_word=$2
10850 echo "$as_me:$LINENO: checking for $ac_word" >&5
10851 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10852 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10853   echo $ECHO_N "(cached) $ECHO_C" >&6
10854 else
10855   if test -n "$NM_FOR_TARGET"; then
10856   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10857 else
10858 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10859 for as_dir in $PATH
10860 do
10861   IFS=$as_save_IFS
10862   test -z "$as_dir" && as_dir=.
10863   for ac_exec_ext in '' $ac_executable_extensions; do
10864   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10865     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10866     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10867     break 2
10868   fi
10869 done
10870 done
10871
10872 fi
10873 fi
10874 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10875 if test -n "$NM_FOR_TARGET"; then
10876   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10877 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10878 else
10879   echo "$as_me:$LINENO: result: no" >&5
10880 echo "${ECHO_T}no" >&6
10881 fi
10882
10883     fi
10884     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10885   done
10886 fi
10887
10888 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10889   set dummy nm
10890   if test $build = $target ; then
10891     NM_FOR_TARGET="$2"
10892   else
10893     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10894   fi
10895 else
10896   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10897 fi
10898
10899 else
10900   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10901 fi
10902
10903
10904
10905
10906 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10907   if test -n "$with_build_time_tools"; then
10908     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10909 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10910     if test -x $with_build_time_tools/objdump; then
10911       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10912       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10913       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10914 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10915     else
10916       echo "$as_me:$LINENO: result: no" >&5
10917 echo "${ECHO_T}no" >&6
10918     fi
10919   elif test $build != $host && test $have_gcc_for_target = yes; then
10920     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10921     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10922     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10923   fi
10924 fi
10925 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10926   # Extract the first word of "objdump", so it can be a program name with args.
10927 set dummy objdump; ac_word=$2
10928 echo "$as_me:$LINENO: checking for $ac_word" >&5
10929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10930 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10931   echo $ECHO_N "(cached) $ECHO_C" >&6
10932 else
10933   case $OBJDUMP_FOR_TARGET in
10934   [\\/]* | ?:[\\/]*)
10935   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10936   ;;
10937   *)
10938   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10939 for as_dir in $gcc_cv_tool_dirs
10940 do
10941   IFS=$as_save_IFS
10942   test -z "$as_dir" && as_dir=.
10943   for ac_exec_ext in '' $ac_executable_extensions; do
10944   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10945     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10946     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10947     break 2
10948   fi
10949 done
10950 done
10951
10952   ;;
10953 esac
10954 fi
10955 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10956
10957 if test -n "$OBJDUMP_FOR_TARGET"; then
10958   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10959 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10960 else
10961   echo "$as_me:$LINENO: result: no" >&5
10962 echo "${ECHO_T}no" >&6
10963 fi
10964
10965 fi
10966 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10967
10968
10969 if test -n "$OBJDUMP_FOR_TARGET"; then
10970   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10971 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10972   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10973 fi
10974
10975 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10976   for ncn_progname in objdump; do
10977     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10978 set dummy ${ncn_progname}; ac_word=$2
10979 echo "$as_me:$LINENO: checking for $ac_word" >&5
10980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10981 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10982   echo $ECHO_N "(cached) $ECHO_C" >&6
10983 else
10984   if test -n "$OBJDUMP_FOR_TARGET"; then
10985   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10986 else
10987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10988 for as_dir in $PATH
10989 do
10990   IFS=$as_save_IFS
10991   test -z "$as_dir" && as_dir=.
10992   for ac_exec_ext in '' $ac_executable_extensions; do
10993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10994     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10996     break 2
10997   fi
10998 done
10999 done
11000
11001 fi
11002 fi
11003 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11004 if test -n "$OBJDUMP_FOR_TARGET"; then
11005   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11006 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11007 else
11008   echo "$as_me:$LINENO: result: no" >&5
11009 echo "${ECHO_T}no" >&6
11010 fi
11011
11012   done
11013 fi
11014
11015 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11016   for ncn_progname in objdump; do
11017     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11018 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11019     if test -x $with_build_time_tools/${ncn_progname}; then
11020       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11021       echo "$as_me:$LINENO: result: yes" >&5
11022 echo "${ECHO_T}yes" >&6
11023       break
11024     else
11025       echo "$as_me:$LINENO: result: no" >&5
11026 echo "${ECHO_T}no" >&6
11027     fi
11028   done
11029 fi
11030
11031 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
11032   for ncn_progname in objdump; do
11033     if test -n "$ncn_target_tool_prefix"; then
11034       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11035 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11036 echo "$as_me:$LINENO: checking for $ac_word" >&5
11037 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11038 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11039   echo $ECHO_N "(cached) $ECHO_C" >&6
11040 else
11041   if test -n "$OBJDUMP_FOR_TARGET"; then
11042   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11043 else
11044 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11045 for as_dir in $PATH
11046 do
11047   IFS=$as_save_IFS
11048   test -z "$as_dir" && as_dir=.
11049   for ac_exec_ext in '' $ac_executable_extensions; do
11050   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11051     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11052     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11053     break 2
11054   fi
11055 done
11056 done
11057
11058 fi
11059 fi
11060 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11061 if test -n "$OBJDUMP_FOR_TARGET"; then
11062   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11063 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11064 else
11065   echo "$as_me:$LINENO: result: no" >&5
11066 echo "${ECHO_T}no" >&6
11067 fi
11068
11069     fi
11070     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
11071       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11072 set dummy ${ncn_progname}; ac_word=$2
11073 echo "$as_me:$LINENO: checking for $ac_word" >&5
11074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11075 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11076   echo $ECHO_N "(cached) $ECHO_C" >&6
11077 else
11078   if test -n "$OBJDUMP_FOR_TARGET"; then
11079   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11080 else
11081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11082 for as_dir in $PATH
11083 do
11084   IFS=$as_save_IFS
11085   test -z "$as_dir" && as_dir=.
11086   for ac_exec_ext in '' $ac_executable_extensions; do
11087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11088     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
11089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11090     break 2
11091   fi
11092 done
11093 done
11094
11095 fi
11096 fi
11097 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11098 if test -n "$OBJDUMP_FOR_TARGET"; then
11099   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11100 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11101 else
11102   echo "$as_me:$LINENO: result: no" >&5
11103 echo "${ECHO_T}no" >&6
11104 fi
11105
11106     fi
11107     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11108   done
11109 fi
11110
11111 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11112   set dummy objdump
11113   if test $build = $target ; then
11114     OBJDUMP_FOR_TARGET="$2"
11115   else
11116     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11117   fi
11118 else
11119   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11120 fi
11121
11122 else
11123   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11124 fi
11125
11126
11127
11128
11129 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11130   if test -n "$with_build_time_tools"; then
11131     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11132 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11133     if test -x $with_build_time_tools/ranlib; then
11134       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11135       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11136       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11137 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11138     else
11139       echo "$as_me:$LINENO: result: no" >&5
11140 echo "${ECHO_T}no" >&6
11141     fi
11142   elif test $build != $host && test $have_gcc_for_target = yes; then
11143     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11144     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11145     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11146   fi
11147 fi
11148 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11149   # Extract the first word of "ranlib", so it can be a program name with args.
11150 set dummy ranlib; ac_word=$2
11151 echo "$as_me:$LINENO: checking for $ac_word" >&5
11152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11153 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11154   echo $ECHO_N "(cached) $ECHO_C" >&6
11155 else
11156   case $RANLIB_FOR_TARGET in
11157   [\\/]* | ?:[\\/]*)
11158   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11159   ;;
11160   *)
11161   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11162 for as_dir in $gcc_cv_tool_dirs
11163 do
11164   IFS=$as_save_IFS
11165   test -z "$as_dir" && as_dir=.
11166   for ac_exec_ext in '' $ac_executable_extensions; do
11167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11168     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11169     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11170     break 2
11171   fi
11172 done
11173 done
11174
11175   ;;
11176 esac
11177 fi
11178 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11179
11180 if test -n "$RANLIB_FOR_TARGET"; then
11181   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11182 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11183 else
11184   echo "$as_me:$LINENO: result: no" >&5
11185 echo "${ECHO_T}no" >&6
11186 fi
11187
11188 fi
11189 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11190
11191
11192 if test -n "$RANLIB_FOR_TARGET"; then
11193   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11194 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11195   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11196 fi
11197
11198 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11199   for ncn_progname in ranlib; do
11200     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11201 set dummy ${ncn_progname}; ac_word=$2
11202 echo "$as_me:$LINENO: checking for $ac_word" >&5
11203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11204 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11205   echo $ECHO_N "(cached) $ECHO_C" >&6
11206 else
11207   if test -n "$RANLIB_FOR_TARGET"; then
11208   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11209 else
11210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11211 for as_dir in $PATH
11212 do
11213   IFS=$as_save_IFS
11214   test -z "$as_dir" && as_dir=.
11215   for ac_exec_ext in '' $ac_executable_extensions; do
11216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11217     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11219     break 2
11220   fi
11221 done
11222 done
11223
11224 fi
11225 fi
11226 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11227 if test -n "$RANLIB_FOR_TARGET"; then
11228   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11229 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11230 else
11231   echo "$as_me:$LINENO: result: no" >&5
11232 echo "${ECHO_T}no" >&6
11233 fi
11234
11235   done
11236 fi
11237
11238 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11239   for ncn_progname in ranlib; do
11240     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11241 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11242     if test -x $with_build_time_tools/${ncn_progname}; then
11243       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11244       echo "$as_me:$LINENO: result: yes" >&5
11245 echo "${ECHO_T}yes" >&6
11246       break
11247     else
11248       echo "$as_me:$LINENO: result: no" >&5
11249 echo "${ECHO_T}no" >&6
11250     fi
11251   done
11252 fi
11253
11254 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11255   for ncn_progname in ranlib; do
11256     if test -n "$ncn_target_tool_prefix"; then
11257       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11258 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11259 echo "$as_me:$LINENO: checking for $ac_word" >&5
11260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11261 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11262   echo $ECHO_N "(cached) $ECHO_C" >&6
11263 else
11264   if test -n "$RANLIB_FOR_TARGET"; then
11265   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11266 else
11267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11268 for as_dir in $PATH
11269 do
11270   IFS=$as_save_IFS
11271   test -z "$as_dir" && as_dir=.
11272   for ac_exec_ext in '' $ac_executable_extensions; do
11273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11274     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11276     break 2
11277   fi
11278 done
11279 done
11280
11281 fi
11282 fi
11283 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11284 if test -n "$RANLIB_FOR_TARGET"; then
11285   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11286 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11287 else
11288   echo "$as_me:$LINENO: result: no" >&5
11289 echo "${ECHO_T}no" >&6
11290 fi
11291
11292     fi
11293     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11294       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11295 set dummy ${ncn_progname}; ac_word=$2
11296 echo "$as_me:$LINENO: checking for $ac_word" >&5
11297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11298 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11299   echo $ECHO_N "(cached) $ECHO_C" >&6
11300 else
11301   if test -n "$RANLIB_FOR_TARGET"; then
11302   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11303 else
11304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11305 for as_dir in $PATH
11306 do
11307   IFS=$as_save_IFS
11308   test -z "$as_dir" && as_dir=.
11309   for ac_exec_ext in '' $ac_executable_extensions; do
11310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11311     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11313     break 2
11314   fi
11315 done
11316 done
11317
11318 fi
11319 fi
11320 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11321 if test -n "$RANLIB_FOR_TARGET"; then
11322   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11323 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11324 else
11325   echo "$as_me:$LINENO: result: no" >&5
11326 echo "${ECHO_T}no" >&6
11327 fi
11328
11329     fi
11330     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11331   done
11332 fi
11333
11334 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11335   set dummy ranlib
11336   if test $build = $target ; then
11337     RANLIB_FOR_TARGET="$2"
11338   else
11339     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11340   fi
11341 else
11342   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11343 fi
11344
11345 else
11346   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11347 fi
11348
11349
11350
11351
11352 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11353   if test -n "$with_build_time_tools"; then
11354     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11355 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11356     if test -x $with_build_time_tools/strip; then
11357       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11358       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11359       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11360 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11361     else
11362       echo "$as_me:$LINENO: result: no" >&5
11363 echo "${ECHO_T}no" >&6
11364     fi
11365   elif test $build != $host && test $have_gcc_for_target = yes; then
11366     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11367     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11368     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11369   fi
11370 fi
11371 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11372   # Extract the first word of "strip", so it can be a program name with args.
11373 set dummy strip; ac_word=$2
11374 echo "$as_me:$LINENO: checking for $ac_word" >&5
11375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11376 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11377   echo $ECHO_N "(cached) $ECHO_C" >&6
11378 else
11379   case $STRIP_FOR_TARGET in
11380   [\\/]* | ?:[\\/]*)
11381   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11382   ;;
11383   *)
11384   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11385 for as_dir in $gcc_cv_tool_dirs
11386 do
11387   IFS=$as_save_IFS
11388   test -z "$as_dir" && as_dir=.
11389   for ac_exec_ext in '' $ac_executable_extensions; do
11390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11391     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11393     break 2
11394   fi
11395 done
11396 done
11397
11398   ;;
11399 esac
11400 fi
11401 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11402
11403 if test -n "$STRIP_FOR_TARGET"; then
11404   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11405 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11406 else
11407   echo "$as_me:$LINENO: result: no" >&5
11408 echo "${ECHO_T}no" >&6
11409 fi
11410
11411 fi
11412 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11413
11414
11415 if test -n "$STRIP_FOR_TARGET"; then
11416   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11417 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11418   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11419 fi
11420
11421 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11422   for ncn_progname in strip; do
11423     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11424 set dummy ${ncn_progname}; ac_word=$2
11425 echo "$as_me:$LINENO: checking for $ac_word" >&5
11426 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11427 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11428   echo $ECHO_N "(cached) $ECHO_C" >&6
11429 else
11430   if test -n "$STRIP_FOR_TARGET"; then
11431   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11432 else
11433 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11434 for as_dir in $PATH
11435 do
11436   IFS=$as_save_IFS
11437   test -z "$as_dir" && as_dir=.
11438   for ac_exec_ext in '' $ac_executable_extensions; do
11439   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11440     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11441     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11442     break 2
11443   fi
11444 done
11445 done
11446
11447 fi
11448 fi
11449 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11450 if test -n "$STRIP_FOR_TARGET"; then
11451   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11452 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11453 else
11454   echo "$as_me:$LINENO: result: no" >&5
11455 echo "${ECHO_T}no" >&6
11456 fi
11457
11458   done
11459 fi
11460
11461 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11462   for ncn_progname in strip; do
11463     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11464 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11465     if test -x $with_build_time_tools/${ncn_progname}; then
11466       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11467       echo "$as_me:$LINENO: result: yes" >&5
11468 echo "${ECHO_T}yes" >&6
11469       break
11470     else
11471       echo "$as_me:$LINENO: result: no" >&5
11472 echo "${ECHO_T}no" >&6
11473     fi
11474   done
11475 fi
11476
11477 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11478   for ncn_progname in strip; do
11479     if test -n "$ncn_target_tool_prefix"; then
11480       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11481 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11482 echo "$as_me:$LINENO: checking for $ac_word" >&5
11483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11484 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11485   echo $ECHO_N "(cached) $ECHO_C" >&6
11486 else
11487   if test -n "$STRIP_FOR_TARGET"; then
11488   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11489 else
11490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11491 for as_dir in $PATH
11492 do
11493   IFS=$as_save_IFS
11494   test -z "$as_dir" && as_dir=.
11495   for ac_exec_ext in '' $ac_executable_extensions; do
11496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11497     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11499     break 2
11500   fi
11501 done
11502 done
11503
11504 fi
11505 fi
11506 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11507 if test -n "$STRIP_FOR_TARGET"; then
11508   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11509 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11510 else
11511   echo "$as_me:$LINENO: result: no" >&5
11512 echo "${ECHO_T}no" >&6
11513 fi
11514
11515     fi
11516     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11517       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11518 set dummy ${ncn_progname}; ac_word=$2
11519 echo "$as_me:$LINENO: checking for $ac_word" >&5
11520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11521 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11522   echo $ECHO_N "(cached) $ECHO_C" >&6
11523 else
11524   if test -n "$STRIP_FOR_TARGET"; then
11525   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11526 else
11527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11528 for as_dir in $PATH
11529 do
11530   IFS=$as_save_IFS
11531   test -z "$as_dir" && as_dir=.
11532   for ac_exec_ext in '' $ac_executable_extensions; do
11533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11534     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11536     break 2
11537   fi
11538 done
11539 done
11540
11541 fi
11542 fi
11543 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11544 if test -n "$STRIP_FOR_TARGET"; then
11545   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11546 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11547 else
11548   echo "$as_me:$LINENO: result: no" >&5
11549 echo "${ECHO_T}no" >&6
11550 fi
11551
11552     fi
11553     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11554   done
11555 fi
11556
11557 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11558   set dummy strip
11559   if test $build = $target ; then
11560     STRIP_FOR_TARGET="$2"
11561   else
11562     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11563   fi
11564 else
11565   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11566 fi
11567
11568 else
11569   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11570 fi
11571
11572
11573
11574
11575 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11576   if test -n "$with_build_time_tools"; then
11577     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11578 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11579     if test -x $with_build_time_tools/windres; then
11580       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11581       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11582       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11583 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11584     else
11585       echo "$as_me:$LINENO: result: no" >&5
11586 echo "${ECHO_T}no" >&6
11587     fi
11588   elif test $build != $host && test $have_gcc_for_target = yes; then
11589     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11590     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11591     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11592   fi
11593 fi
11594 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11595   # Extract the first word of "windres", so it can be a program name with args.
11596 set dummy windres; ac_word=$2
11597 echo "$as_me:$LINENO: checking for $ac_word" >&5
11598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11599 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11600   echo $ECHO_N "(cached) $ECHO_C" >&6
11601 else
11602   case $WINDRES_FOR_TARGET in
11603   [\\/]* | ?:[\\/]*)
11604   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11605   ;;
11606   *)
11607   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11608 for as_dir in $gcc_cv_tool_dirs
11609 do
11610   IFS=$as_save_IFS
11611   test -z "$as_dir" && as_dir=.
11612   for ac_exec_ext in '' $ac_executable_extensions; do
11613   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11614     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11615     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11616     break 2
11617   fi
11618 done
11619 done
11620
11621   ;;
11622 esac
11623 fi
11624 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11625
11626 if test -n "$WINDRES_FOR_TARGET"; then
11627   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11628 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11629 else
11630   echo "$as_me:$LINENO: result: no" >&5
11631 echo "${ECHO_T}no" >&6
11632 fi
11633
11634 fi
11635 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11636
11637
11638 if test -n "$WINDRES_FOR_TARGET"; then
11639   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11640 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11641   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11642 fi
11643
11644 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11645   for ncn_progname in windres; do
11646     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11647 set dummy ${ncn_progname}; ac_word=$2
11648 echo "$as_me:$LINENO: checking for $ac_word" >&5
11649 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11650 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11651   echo $ECHO_N "(cached) $ECHO_C" >&6
11652 else
11653   if test -n "$WINDRES_FOR_TARGET"; then
11654   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11655 else
11656 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11657 for as_dir in $PATH
11658 do
11659   IFS=$as_save_IFS
11660   test -z "$as_dir" && as_dir=.
11661   for ac_exec_ext in '' $ac_executable_extensions; do
11662   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11663     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11664     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11665     break 2
11666   fi
11667 done
11668 done
11669
11670 fi
11671 fi
11672 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11673 if test -n "$WINDRES_FOR_TARGET"; then
11674   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11675 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11676 else
11677   echo "$as_me:$LINENO: result: no" >&5
11678 echo "${ECHO_T}no" >&6
11679 fi
11680
11681   done
11682 fi
11683
11684 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11685   for ncn_progname in windres; do
11686     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11687 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11688     if test -x $with_build_time_tools/${ncn_progname}; then
11689       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11690       echo "$as_me:$LINENO: result: yes" >&5
11691 echo "${ECHO_T}yes" >&6
11692       break
11693     else
11694       echo "$as_me:$LINENO: result: no" >&5
11695 echo "${ECHO_T}no" >&6
11696     fi
11697   done
11698 fi
11699
11700 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11701   for ncn_progname in windres; do
11702     if test -n "$ncn_target_tool_prefix"; then
11703       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11704 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11705 echo "$as_me:$LINENO: checking for $ac_word" >&5
11706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11707 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11708   echo $ECHO_N "(cached) $ECHO_C" >&6
11709 else
11710   if test -n "$WINDRES_FOR_TARGET"; then
11711   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11712 else
11713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11714 for as_dir in $PATH
11715 do
11716   IFS=$as_save_IFS
11717   test -z "$as_dir" && as_dir=.
11718   for ac_exec_ext in '' $ac_executable_extensions; do
11719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11720     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11722     break 2
11723   fi
11724 done
11725 done
11726
11727 fi
11728 fi
11729 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11730 if test -n "$WINDRES_FOR_TARGET"; then
11731   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11732 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11733 else
11734   echo "$as_me:$LINENO: result: no" >&5
11735 echo "${ECHO_T}no" >&6
11736 fi
11737
11738     fi
11739     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11740       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11741 set dummy ${ncn_progname}; ac_word=$2
11742 echo "$as_me:$LINENO: checking for $ac_word" >&5
11743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11744 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11745   echo $ECHO_N "(cached) $ECHO_C" >&6
11746 else
11747   if test -n "$WINDRES_FOR_TARGET"; then
11748   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11749 else
11750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11751 for as_dir in $PATH
11752 do
11753   IFS=$as_save_IFS
11754   test -z "$as_dir" && as_dir=.
11755   for ac_exec_ext in '' $ac_executable_extensions; do
11756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11757     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11759     break 2
11760   fi
11761 done
11762 done
11763
11764 fi
11765 fi
11766 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11767 if test -n "$WINDRES_FOR_TARGET"; then
11768   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11769 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11770 else
11771   echo "$as_me:$LINENO: result: no" >&5
11772 echo "${ECHO_T}no" >&6
11773 fi
11774
11775     fi
11776     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11777   done
11778 fi
11779
11780 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11781   set dummy windres
11782   if test $build = $target ; then
11783     WINDRES_FOR_TARGET="$2"
11784   else
11785     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11786   fi
11787 else
11788   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11789 fi
11790
11791 else
11792   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11793 fi
11794
11795
11796
11797
11798 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11799   if test -n "$with_build_time_tools"; then
11800     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11801 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11802     if test -x $with_build_time_tools/windmc; then
11803       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11804       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11805       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11806 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11807     else
11808       echo "$as_me:$LINENO: result: no" >&5
11809 echo "${ECHO_T}no" >&6
11810     fi
11811   elif test $build != $host && test $have_gcc_for_target = yes; then
11812     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11813     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11814     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11815   fi
11816 fi
11817 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11818   # Extract the first word of "windmc", so it can be a program name with args.
11819 set dummy windmc; ac_word=$2
11820 echo "$as_me:$LINENO: checking for $ac_word" >&5
11821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11822 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11823   echo $ECHO_N "(cached) $ECHO_C" >&6
11824 else
11825   case $WINDMC_FOR_TARGET in
11826   [\\/]* | ?:[\\/]*)
11827   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11828   ;;
11829   *)
11830   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11831 for as_dir in $gcc_cv_tool_dirs
11832 do
11833   IFS=$as_save_IFS
11834   test -z "$as_dir" && as_dir=.
11835   for ac_exec_ext in '' $ac_executable_extensions; do
11836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11837     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11839     break 2
11840   fi
11841 done
11842 done
11843
11844   ;;
11845 esac
11846 fi
11847 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11848
11849 if test -n "$WINDMC_FOR_TARGET"; then
11850   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11851 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11852 else
11853   echo "$as_me:$LINENO: result: no" >&5
11854 echo "${ECHO_T}no" >&6
11855 fi
11856
11857 fi
11858 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11859
11860
11861 if test -n "$WINDMC_FOR_TARGET"; then
11862   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11863 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11864   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11865 fi
11866
11867 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11868   for ncn_progname in windmc; do
11869     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11870 set dummy ${ncn_progname}; ac_word=$2
11871 echo "$as_me:$LINENO: checking for $ac_word" >&5
11872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11873 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11874   echo $ECHO_N "(cached) $ECHO_C" >&6
11875 else
11876   if test -n "$WINDMC_FOR_TARGET"; then
11877   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11878 else
11879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11880 for as_dir in $PATH
11881 do
11882   IFS=$as_save_IFS
11883   test -z "$as_dir" && as_dir=.
11884   for ac_exec_ext in '' $ac_executable_extensions; do
11885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11886     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11888     break 2
11889   fi
11890 done
11891 done
11892
11893 fi
11894 fi
11895 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11896 if test -n "$WINDMC_FOR_TARGET"; then
11897   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11898 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11899 else
11900   echo "$as_me:$LINENO: result: no" >&5
11901 echo "${ECHO_T}no" >&6
11902 fi
11903
11904   done
11905 fi
11906
11907 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11908   for ncn_progname in windmc; do
11909     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11910 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11911     if test -x $with_build_time_tools/${ncn_progname}; then
11912       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11913       echo "$as_me:$LINENO: result: yes" >&5
11914 echo "${ECHO_T}yes" >&6
11915       break
11916     else
11917       echo "$as_me:$LINENO: result: no" >&5
11918 echo "${ECHO_T}no" >&6
11919     fi
11920   done
11921 fi
11922
11923 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11924   for ncn_progname in windmc; do
11925     if test -n "$ncn_target_tool_prefix"; then
11926       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11927 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11928 echo "$as_me:$LINENO: checking for $ac_word" >&5
11929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11930 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11931   echo $ECHO_N "(cached) $ECHO_C" >&6
11932 else
11933   if test -n "$WINDMC_FOR_TARGET"; then
11934   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11935 else
11936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11937 for as_dir in $PATH
11938 do
11939   IFS=$as_save_IFS
11940   test -z "$as_dir" && as_dir=.
11941   for ac_exec_ext in '' $ac_executable_extensions; do
11942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11943     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11945     break 2
11946   fi
11947 done
11948 done
11949
11950 fi
11951 fi
11952 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11953 if test -n "$WINDMC_FOR_TARGET"; then
11954   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11955 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11956 else
11957   echo "$as_me:$LINENO: result: no" >&5
11958 echo "${ECHO_T}no" >&6
11959 fi
11960
11961     fi
11962     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11963       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11964 set dummy ${ncn_progname}; ac_word=$2
11965 echo "$as_me:$LINENO: checking for $ac_word" >&5
11966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11967 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11968   echo $ECHO_N "(cached) $ECHO_C" >&6
11969 else
11970   if test -n "$WINDMC_FOR_TARGET"; then
11971   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11972 else
11973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11974 for as_dir in $PATH
11975 do
11976   IFS=$as_save_IFS
11977   test -z "$as_dir" && as_dir=.
11978   for ac_exec_ext in '' $ac_executable_extensions; do
11979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11980     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11982     break 2
11983   fi
11984 done
11985 done
11986
11987 fi
11988 fi
11989 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11990 if test -n "$WINDMC_FOR_TARGET"; then
11991   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11992 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11993 else
11994   echo "$as_me:$LINENO: result: no" >&5
11995 echo "${ECHO_T}no" >&6
11996 fi
11997
11998     fi
11999     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
12000   done
12001 fi
12002
12003 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
12004   set dummy windmc
12005   if test $build = $target ; then
12006     WINDMC_FOR_TARGET="$2"
12007   else
12008     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
12009   fi
12010 else
12011   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
12012 fi
12013
12014 else
12015   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
12016 fi
12017
12018
12019 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
12020
12021 echo "$as_me:$LINENO: checking where to find the target ar" >&5
12022 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
12023 if test "x${build}" != "x${host}" ; then
12024   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12025     # We already found the complete path
12026     ac_dir=`dirname $AR_FOR_TARGET`
12027     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12028 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12029   else
12030     # Canadian cross, just use what we found
12031     echo "$as_me:$LINENO: result: pre-installed" >&5
12032 echo "${ECHO_T}pre-installed" >&6
12033   fi
12034 else
12035   ok=yes
12036   case " ${configdirs} " in
12037     *" binutils "*) ;;
12038     *) ok=no ;;
12039   esac
12040
12041   if test $ok = yes; then
12042     # An in-tree tool is available and we can use it
12043     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
12044     echo "$as_me:$LINENO: result: just compiled" >&5
12045 echo "${ECHO_T}just compiled" >&6
12046   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12047     # We already found the complete path
12048     ac_dir=`dirname $AR_FOR_TARGET`
12049     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12050 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12051   elif test "x$target" = "x$host"; then
12052     # We can use an host tool
12053     AR_FOR_TARGET='$(AR)'
12054     echo "$as_me:$LINENO: result: host tool" >&5
12055 echo "${ECHO_T}host tool" >&6
12056   else
12057     # We need a cross tool
12058     echo "$as_me:$LINENO: result: pre-installed" >&5
12059 echo "${ECHO_T}pre-installed" >&6
12060   fi
12061 fi
12062
12063 echo "$as_me:$LINENO: checking where to find the target as" >&5
12064 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
12065 if test "x${build}" != "x${host}" ; then
12066   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12067     # We already found the complete path
12068     ac_dir=`dirname $AS_FOR_TARGET`
12069     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12070 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12071   else
12072     # Canadian cross, just use what we found
12073     echo "$as_me:$LINENO: result: pre-installed" >&5
12074 echo "${ECHO_T}pre-installed" >&6
12075   fi
12076 else
12077   ok=yes
12078   case " ${configdirs} " in
12079     *" gas "*) ;;
12080     *) ok=no ;;
12081   esac
12082
12083   if test $ok = yes; then
12084     # An in-tree tool is available and we can use it
12085     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
12086     echo "$as_me:$LINENO: result: just compiled" >&5
12087 echo "${ECHO_T}just compiled" >&6
12088   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12089     # We already found the complete path
12090     ac_dir=`dirname $AS_FOR_TARGET`
12091     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12092 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12093   elif test "x$target" = "x$host"; then
12094     # We can use an host tool
12095     AS_FOR_TARGET='$(AS)'
12096     echo "$as_me:$LINENO: result: host tool" >&5
12097 echo "${ECHO_T}host tool" >&6
12098   else
12099     # We need a cross tool
12100     echo "$as_me:$LINENO: result: pre-installed" >&5
12101 echo "${ECHO_T}pre-installed" >&6
12102   fi
12103 fi
12104
12105 echo "$as_me:$LINENO: checking where to find the target cc" >&5
12106 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12107 if test "x${build}" != "x${host}" ; then
12108   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12109     # We already found the complete path
12110     ac_dir=`dirname $CC_FOR_TARGET`
12111     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12112 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12113   else
12114     # Canadian cross, just use what we found
12115     echo "$as_me:$LINENO: result: pre-installed" >&5
12116 echo "${ECHO_T}pre-installed" >&6
12117   fi
12118 else
12119   ok=yes
12120   case " ${configdirs} " in
12121     *" gcc "*) ;;
12122     *) ok=no ;;
12123   esac
12124
12125   if test $ok = yes; then
12126     # An in-tree tool is available and we can use it
12127     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12128     echo "$as_me:$LINENO: result: just compiled" >&5
12129 echo "${ECHO_T}just compiled" >&6
12130   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12131     # We already found the complete path
12132     ac_dir=`dirname $CC_FOR_TARGET`
12133     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12134 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12135   elif test "x$target" = "x$host"; then
12136     # We can use an host tool
12137     CC_FOR_TARGET='$(CC)'
12138     echo "$as_me:$LINENO: result: host tool" >&5
12139 echo "${ECHO_T}host tool" >&6
12140   else
12141     # We need a cross tool
12142     echo "$as_me:$LINENO: result: pre-installed" >&5
12143 echo "${ECHO_T}pre-installed" >&6
12144   fi
12145 fi
12146
12147 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12148 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12149 if test "x${build}" != "x${host}" ; then
12150   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12151     # We already found the complete path
12152     ac_dir=`dirname $CXX_FOR_TARGET`
12153     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12154 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12155   else
12156     # Canadian cross, just use what we found
12157     echo "$as_me:$LINENO: result: pre-installed" >&5
12158 echo "${ECHO_T}pre-installed" >&6
12159   fi
12160 else
12161   ok=yes
12162   case " ${configdirs} " in
12163     *" gcc "*) ;;
12164     *) ok=no ;;
12165   esac
12166   case ,${enable_languages}, in
12167     *,c++,*) ;;
12168     *) ok=no ;;
12169   esac
12170   if test $ok = yes; then
12171     # An in-tree tool is available and we can use it
12172     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'
12173     echo "$as_me:$LINENO: result: just compiled" >&5
12174 echo "${ECHO_T}just compiled" >&6
12175   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12176     # We already found the complete path
12177     ac_dir=`dirname $CXX_FOR_TARGET`
12178     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12179 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12180   elif test "x$target" = "x$host"; then
12181     # We can use an host tool
12182     CXX_FOR_TARGET='$(CXX)'
12183     echo "$as_me:$LINENO: result: host tool" >&5
12184 echo "${ECHO_T}host tool" >&6
12185   else
12186     # We need a cross tool
12187     echo "$as_me:$LINENO: result: pre-installed" >&5
12188 echo "${ECHO_T}pre-installed" >&6
12189   fi
12190 fi
12191
12192 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12193 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12194 if test "x${build}" != "x${host}" ; then
12195   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12196     # We already found the complete path
12197     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12198     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12199 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12200   else
12201     # Canadian cross, just use what we found
12202     echo "$as_me:$LINENO: result: pre-installed" >&5
12203 echo "${ECHO_T}pre-installed" >&6
12204   fi
12205 else
12206   ok=yes
12207   case " ${configdirs} " in
12208     *" gcc "*) ;;
12209     *) ok=no ;;
12210   esac
12211   case ,${enable_languages}, in
12212     *,c++,*) ;;
12213     *) ok=no ;;
12214   esac
12215   if test $ok = yes; then
12216     # An in-tree tool is available and we can use it
12217     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'
12218     echo "$as_me:$LINENO: result: just compiled" >&5
12219 echo "${ECHO_T}just compiled" >&6
12220   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12221     # We already found the complete path
12222     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12223     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12224 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12225   elif test "x$target" = "x$host"; then
12226     # We can use an host tool
12227     RAW_CXX_FOR_TARGET='$(CXX)'
12228     echo "$as_me:$LINENO: result: host tool" >&5
12229 echo "${ECHO_T}host tool" >&6
12230   else
12231     # We need a cross tool
12232     echo "$as_me:$LINENO: result: pre-installed" >&5
12233 echo "${ECHO_T}pre-installed" >&6
12234   fi
12235 fi
12236
12237 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12238 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12239 if test "x${build}" != "x${host}" ; then
12240   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12241     # We already found the complete path
12242     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12243     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12244 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12245   else
12246     # Canadian cross, just use what we found
12247     echo "$as_me:$LINENO: result: pre-installed" >&5
12248 echo "${ECHO_T}pre-installed" >&6
12249   fi
12250 else
12251   ok=yes
12252   case " ${configdirs} " in
12253     *" binutils "*) ;;
12254     *) ok=no ;;
12255   esac
12256
12257   if test $ok = yes; then
12258     # An in-tree tool is available and we can use it
12259     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12260     echo "$as_me:$LINENO: result: just compiled" >&5
12261 echo "${ECHO_T}just compiled" >&6
12262   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12263     # We already found the complete path
12264     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12265     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12266 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12267   elif test "x$target" = "x$host"; then
12268     # We can use an host tool
12269     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12270     echo "$as_me:$LINENO: result: host tool" >&5
12271 echo "${ECHO_T}host tool" >&6
12272   else
12273     # We need a cross tool
12274     echo "$as_me:$LINENO: result: pre-installed" >&5
12275 echo "${ECHO_T}pre-installed" >&6
12276   fi
12277 fi
12278
12279 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12280 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12281 if test "x${build}" != "x${host}" ; then
12282   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12283     # We already found the complete path
12284     ac_dir=`dirname $GCC_FOR_TARGET`
12285     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12286 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12287   else
12288     # Canadian cross, just use what we found
12289     echo "$as_me:$LINENO: result: pre-installed" >&5
12290 echo "${ECHO_T}pre-installed" >&6
12291   fi
12292 else
12293   ok=yes
12294   case " ${configdirs} " in
12295     *" gcc "*) ;;
12296     *) ok=no ;;
12297   esac
12298
12299   if test $ok = yes; then
12300     # An in-tree tool is available and we can use it
12301     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12302     echo "$as_me:$LINENO: result: just compiled" >&5
12303 echo "${ECHO_T}just compiled" >&6
12304   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12305     # We already found the complete path
12306     ac_dir=`dirname $GCC_FOR_TARGET`
12307     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12308 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12309   elif test "x$target" = "x$host"; then
12310     # We can use an host tool
12311     GCC_FOR_TARGET='$()'
12312     echo "$as_me:$LINENO: result: host tool" >&5
12313 echo "${ECHO_T}host tool" >&6
12314   else
12315     # We need a cross tool
12316     echo "$as_me:$LINENO: result: pre-installed" >&5
12317 echo "${ECHO_T}pre-installed" >&6
12318   fi
12319 fi
12320
12321 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12322 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12323 if test "x${build}" != "x${host}" ; then
12324   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12325     # We already found the complete path
12326     ac_dir=`dirname $GCJ_FOR_TARGET`
12327     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12328 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12329   else
12330     # Canadian cross, just use what we found
12331     echo "$as_me:$LINENO: result: pre-installed" >&5
12332 echo "${ECHO_T}pre-installed" >&6
12333   fi
12334 else
12335   ok=yes
12336   case " ${configdirs} " in
12337     *" gcc "*) ;;
12338     *) ok=no ;;
12339   esac
12340   case ,${enable_languages}, in
12341     *,java,*) ;;
12342     *) ok=no ;;
12343   esac
12344   if test $ok = yes; then
12345     # An in-tree tool is available and we can use it
12346     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12347     echo "$as_me:$LINENO: result: just compiled" >&5
12348 echo "${ECHO_T}just compiled" >&6
12349   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12350     # We already found the complete path
12351     ac_dir=`dirname $GCJ_FOR_TARGET`
12352     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12353 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12354   elif test "x$target" = "x$host"; then
12355     # We can use an host tool
12356     GCJ_FOR_TARGET='$(GCJ)'
12357     echo "$as_me:$LINENO: result: host tool" >&5
12358 echo "${ECHO_T}host tool" >&6
12359   else
12360     # We need a cross tool
12361     echo "$as_me:$LINENO: result: pre-installed" >&5
12362 echo "${ECHO_T}pre-installed" >&6
12363   fi
12364 fi
12365
12366 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12367 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12368 if test "x${build}" != "x${host}" ; then
12369   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12370     # We already found the complete path
12371     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12372     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12373 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12374   else
12375     # Canadian cross, just use what we found
12376     echo "$as_me:$LINENO: result: pre-installed" >&5
12377 echo "${ECHO_T}pre-installed" >&6
12378   fi
12379 else
12380   ok=yes
12381   case " ${configdirs} " in
12382     *" gcc "*) ;;
12383     *) ok=no ;;
12384   esac
12385   case ,${enable_languages}, in
12386     *,fortran,*) ;;
12387     *) ok=no ;;
12388   esac
12389   if test $ok = yes; then
12390     # An in-tree tool is available and we can use it
12391     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12392     echo "$as_me:$LINENO: result: just compiled" >&5
12393 echo "${ECHO_T}just compiled" >&6
12394   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12395     # We already found the complete path
12396     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12397     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12398 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12399   elif test "x$target" = "x$host"; then
12400     # We can use an host tool
12401     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12402     echo "$as_me:$LINENO: result: host tool" >&5
12403 echo "${ECHO_T}host tool" >&6
12404   else
12405     # We need a cross tool
12406     echo "$as_me:$LINENO: result: pre-installed" >&5
12407 echo "${ECHO_T}pre-installed" >&6
12408   fi
12409 fi
12410
12411 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12412 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12413 if test "x${build}" != "x${host}" ; then
12414   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12415     # We already found the complete path
12416     ac_dir=`dirname $LD_FOR_TARGET`
12417     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12418 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12419   else
12420     # Canadian cross, just use what we found
12421     echo "$as_me:$LINENO: result: pre-installed" >&5
12422 echo "${ECHO_T}pre-installed" >&6
12423   fi
12424 else
12425   ok=yes
12426   case " ${configdirs} " in
12427     *" ld "*) ;;
12428     *) ok=no ;;
12429   esac
12430
12431   if test $ok = yes; then
12432     # An in-tree tool is available and we can use it
12433     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12434     echo "$as_me:$LINENO: result: just compiled" >&5
12435 echo "${ECHO_T}just compiled" >&6
12436   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12437     # We already found the complete path
12438     ac_dir=`dirname $LD_FOR_TARGET`
12439     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12440 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12441   elif test "x$target" = "x$host"; then
12442     # We can use an host tool
12443     LD_FOR_TARGET='$(LD)'
12444     echo "$as_me:$LINENO: result: host tool" >&5
12445 echo "${ECHO_T}host tool" >&6
12446   else
12447     # We need a cross tool
12448     echo "$as_me:$LINENO: result: pre-installed" >&5
12449 echo "${ECHO_T}pre-installed" >&6
12450   fi
12451 fi
12452
12453 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12454 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12455 if test "x${build}" != "x${host}" ; then
12456   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12457     # We already found the complete path
12458     ac_dir=`dirname $LIPO_FOR_TARGET`
12459     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12460 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12461   else
12462     # Canadian cross, just use what we found
12463     echo "$as_me:$LINENO: result: pre-installed" >&5
12464 echo "${ECHO_T}pre-installed" >&6
12465   fi
12466 else
12467   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12468     # We already found the complete path
12469     ac_dir=`dirname $LIPO_FOR_TARGET`
12470     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12471 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12472   elif test "x$target" = "x$host"; then
12473     # We can use an host tool
12474     LIPO_FOR_TARGET='$(LIPO)'
12475     echo "$as_me:$LINENO: result: host tool" >&5
12476 echo "${ECHO_T}host tool" >&6
12477   else
12478     # We need a cross tool
12479     echo "$as_me:$LINENO: result: pre-installed" >&5
12480 echo "${ECHO_T}pre-installed" >&6
12481   fi
12482 fi
12483
12484 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12485 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12486 if test "x${build}" != "x${host}" ; then
12487   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12488     # We already found the complete path
12489     ac_dir=`dirname $NM_FOR_TARGET`
12490     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12491 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12492   else
12493     # Canadian cross, just use what we found
12494     echo "$as_me:$LINENO: result: pre-installed" >&5
12495 echo "${ECHO_T}pre-installed" >&6
12496   fi
12497 else
12498   ok=yes
12499   case " ${configdirs} " in
12500     *" binutils "*) ;;
12501     *) ok=no ;;
12502   esac
12503
12504   if test $ok = yes; then
12505     # An in-tree tool is available and we can use it
12506     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12507     echo "$as_me:$LINENO: result: just compiled" >&5
12508 echo "${ECHO_T}just compiled" >&6
12509   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12510     # We already found the complete path
12511     ac_dir=`dirname $NM_FOR_TARGET`
12512     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12513 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12514   elif test "x$target" = "x$host"; then
12515     # We can use an host tool
12516     NM_FOR_TARGET='$(NM)'
12517     echo "$as_me:$LINENO: result: host tool" >&5
12518 echo "${ECHO_T}host tool" >&6
12519   else
12520     # We need a cross tool
12521     echo "$as_me:$LINENO: result: pre-installed" >&5
12522 echo "${ECHO_T}pre-installed" >&6
12523   fi
12524 fi
12525
12526 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12527 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12528 if test "x${build}" != "x${host}" ; then
12529   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12530     # We already found the complete path
12531     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12532     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12533 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12534   else
12535     # Canadian cross, just use what we found
12536     echo "$as_me:$LINENO: result: pre-installed" >&5
12537 echo "${ECHO_T}pre-installed" >&6
12538   fi
12539 else
12540   ok=yes
12541   case " ${configdirs} " in
12542     *" binutils "*) ;;
12543     *) ok=no ;;
12544   esac
12545
12546   if test $ok = yes; then
12547     # An in-tree tool is available and we can use it
12548     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12549     echo "$as_me:$LINENO: result: just compiled" >&5
12550 echo "${ECHO_T}just compiled" >&6
12551   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12552     # We already found the complete path
12553     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12554     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12555 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12556   elif test "x$target" = "x$host"; then
12557     # We can use an host tool
12558     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12559     echo "$as_me:$LINENO: result: host tool" >&5
12560 echo "${ECHO_T}host tool" >&6
12561   else
12562     # We need a cross tool
12563     echo "$as_me:$LINENO: result: pre-installed" >&5
12564 echo "${ECHO_T}pre-installed" >&6
12565   fi
12566 fi
12567
12568 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12569 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12570 if test "x${build}" != "x${host}" ; then
12571   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12572     # We already found the complete path
12573     ac_dir=`dirname $RANLIB_FOR_TARGET`
12574     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12575 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12576   else
12577     # Canadian cross, just use what we found
12578     echo "$as_me:$LINENO: result: pre-installed" >&5
12579 echo "${ECHO_T}pre-installed" >&6
12580   fi
12581 else
12582   ok=yes
12583   case " ${configdirs} " in
12584     *" binutils "*) ;;
12585     *) ok=no ;;
12586   esac
12587
12588   if test $ok = yes; then
12589     # An in-tree tool is available and we can use it
12590     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12591     echo "$as_me:$LINENO: result: just compiled" >&5
12592 echo "${ECHO_T}just compiled" >&6
12593   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12594     # We already found the complete path
12595     ac_dir=`dirname $RANLIB_FOR_TARGET`
12596     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12597 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12598   elif test "x$target" = "x$host"; then
12599     # We can use an host tool
12600     RANLIB_FOR_TARGET='$(RANLIB)'
12601     echo "$as_me:$LINENO: result: host tool" >&5
12602 echo "${ECHO_T}host tool" >&6
12603   else
12604     # We need a cross tool
12605     echo "$as_me:$LINENO: result: pre-installed" >&5
12606 echo "${ECHO_T}pre-installed" >&6
12607   fi
12608 fi
12609
12610 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12611 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12612 if test "x${build}" != "x${host}" ; then
12613   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12614     # We already found the complete path
12615     ac_dir=`dirname $STRIP_FOR_TARGET`
12616     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12617 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12618   else
12619     # Canadian cross, just use what we found
12620     echo "$as_me:$LINENO: result: pre-installed" >&5
12621 echo "${ECHO_T}pre-installed" >&6
12622   fi
12623 else
12624   ok=yes
12625   case " ${configdirs} " in
12626     *" binutils "*) ;;
12627     *) ok=no ;;
12628   esac
12629
12630   if test $ok = yes; then
12631     # An in-tree tool is available and we can use it
12632     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12633     echo "$as_me:$LINENO: result: just compiled" >&5
12634 echo "${ECHO_T}just compiled" >&6
12635   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12636     # We already found the complete path
12637     ac_dir=`dirname $STRIP_FOR_TARGET`
12638     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12639 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12640   elif test "x$target" = "x$host"; then
12641     # We can use an host tool
12642     STRIP_FOR_TARGET='$(STRIP)'
12643     echo "$as_me:$LINENO: result: host tool" >&5
12644 echo "${ECHO_T}host tool" >&6
12645   else
12646     # We need a cross tool
12647     echo "$as_me:$LINENO: result: pre-installed" >&5
12648 echo "${ECHO_T}pre-installed" >&6
12649   fi
12650 fi
12651
12652 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12653 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12654 if test "x${build}" != "x${host}" ; then
12655   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12656     # We already found the complete path
12657     ac_dir=`dirname $WINDRES_FOR_TARGET`
12658     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12659 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12660   else
12661     # Canadian cross, just use what we found
12662     echo "$as_me:$LINENO: result: pre-installed" >&5
12663 echo "${ECHO_T}pre-installed" >&6
12664   fi
12665 else
12666   ok=yes
12667   case " ${configdirs} " in
12668     *" binutils "*) ;;
12669     *) ok=no ;;
12670   esac
12671
12672   if test $ok = yes; then
12673     # An in-tree tool is available and we can use it
12674     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12675     echo "$as_me:$LINENO: result: just compiled" >&5
12676 echo "${ECHO_T}just compiled" >&6
12677   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12678     # We already found the complete path
12679     ac_dir=`dirname $WINDRES_FOR_TARGET`
12680     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12681 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12682   elif test "x$target" = "x$host"; then
12683     # We can use an host tool
12684     WINDRES_FOR_TARGET='$(WINDRES)'
12685     echo "$as_me:$LINENO: result: host tool" >&5
12686 echo "${ECHO_T}host tool" >&6
12687   else
12688     # We need a cross tool
12689     echo "$as_me:$LINENO: result: pre-installed" >&5
12690 echo "${ECHO_T}pre-installed" >&6
12691   fi
12692 fi
12693
12694 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12695 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12696 if test "x${build}" != "x${host}" ; then
12697   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12698     # We already found the complete path
12699     ac_dir=`dirname $WINDMC_FOR_TARGET`
12700     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12701 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12702   else
12703     # Canadian cross, just use what we found
12704     echo "$as_me:$LINENO: result: pre-installed" >&5
12705 echo "${ECHO_T}pre-installed" >&6
12706   fi
12707 else
12708   ok=yes
12709   case " ${configdirs} " in
12710     *" binutils "*) ;;
12711     *) ok=no ;;
12712   esac
12713
12714   if test $ok = yes; then
12715     # An in-tree tool is available and we can use it
12716     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12717     echo "$as_me:$LINENO: result: just compiled" >&5
12718 echo "${ECHO_T}just compiled" >&6
12719   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12720     # We already found the complete path
12721     ac_dir=`dirname $WINDMC_FOR_TARGET`
12722     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12723 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12724   elif test "x$target" = "x$host"; then
12725     # We can use an host tool
12726     WINDMC_FOR_TARGET='$(WINDMC)'
12727     echo "$as_me:$LINENO: result: host tool" >&5
12728 echo "${ECHO_T}host tool" >&6
12729   else
12730     # We need a cross tool
12731     echo "$as_me:$LINENO: result: pre-installed" >&5
12732 echo "${ECHO_T}pre-installed" >&6
12733   fi
12734 fi
12735
12736
12737
12738
12739
12740 # Certain tools may need extra flags.
12741 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12742 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12743 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12744
12745 # When building target libraries, except in a Canadian cross, we use
12746 # the same toolchain as the compiler we just built.
12747 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12748 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12749 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12750 if test $host = $build; then
12751   case " $configdirs " in
12752     *" gcc "*)
12753       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12754       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12755       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12756       ;;
12757   esac
12758 fi
12759
12760
12761
12762
12763
12764 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12765 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12766 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12767 if test "${enable_maintainer_mode+set}" = set; then
12768   enableval="$enable_maintainer_mode"
12769   USE_MAINTAINER_MODE=$enableval
12770 else
12771   USE_MAINTAINER_MODE=no
12772 fi;
12773 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12774 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12775
12776
12777 if test "$USE_MAINTAINER_MODE" = yes; then
12778   MAINTAINER_MODE_TRUE=
12779   MAINTAINER_MODE_FALSE='#'
12780 else
12781   MAINTAINER_MODE_TRUE='#'
12782   MAINTAINER_MODE_FALSE=
12783 fi
12784 MAINT=$MAINTAINER_MODE_TRUE
12785
12786 # ---------------------
12787 # GCC bootstrap support
12788 # ---------------------
12789
12790 # Stage specific cflags for build.
12791 stage1_cflags="-g"
12792 case $build in
12793   vax-*-*)
12794     case ${GCC} in
12795       yes) stage1_cflags="-g -Wa,-J" ;;
12796       *) stage1_cflags="-g -J" ;;
12797     esac ;;
12798 esac
12799
12800 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12801 if test "$GCC" = yes -a "$ENABLE_BUILD_WITH_CXX" != yes; then
12802   saved_CFLAGS="$CFLAGS"
12803
12804   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12805   CFLAGS="$CFLAGS -fkeep-inline-functions"
12806   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12807 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12808   cat >conftest.$ac_ext <<_ACEOF
12809 /* confdefs.h.  */
12810 _ACEOF
12811 cat confdefs.h >>conftest.$ac_ext
12812 cat >>conftest.$ac_ext <<_ACEOF
12813 /* end confdefs.h.  */
12814
12815 #if (__GNUC__ < 3) \
12816     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12817                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12818 #error http://gcc.gnu.org/PR29382
12819 #endif
12820
12821 int
12822 main ()
12823 {
12824
12825   ;
12826   return 0;
12827 }
12828 _ACEOF
12829 rm -f conftest.$ac_objext
12830 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12831   (eval $ac_compile) 2>conftest.er1
12832   ac_status=$?
12833   grep -v '^ *+' conftest.er1 >conftest.err
12834   rm -f conftest.er1
12835   cat conftest.err >&5
12836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12837   (exit $ac_status); } &&
12838          { ac_try='test -z "$ac_c_werror_flag"
12839                          || test ! -s conftest.err'
12840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12841   (eval $ac_try) 2>&5
12842   ac_status=$?
12843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12844   (exit $ac_status); }; } &&
12845          { ac_try='test -s conftest.$ac_objext'
12846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12847   (eval $ac_try) 2>&5
12848   ac_status=$?
12849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12850   (exit $ac_status); }; }; then
12851   echo "$as_me:$LINENO: result: yes" >&5
12852 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12853 else
12854   echo "$as_me: failed program was:" >&5
12855 sed 's/^/| /' conftest.$ac_ext >&5
12856
12857 echo "$as_me:$LINENO: result: no" >&5
12858 echo "${ECHO_T}no" >&6
12859 fi
12860 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12861
12862   CFLAGS="$saved_CFLAGS"
12863 fi
12864
12865
12866
12867 # Enable --enable-checking in stage1 of the compiler.
12868 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12869 if test "${enable_stage1_checking+set}" = set; then
12870   enableval="$enable_stage1_checking"
12871   stage1_checking=--enable-checking=${enable_stage1_checking}
12872 else
12873   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12874   stage1_checking=--enable-checking=yes,types
12875 else
12876   stage1_checking=--enable-checking=$enable_checking,types
12877 fi
12878 fi;
12879
12880
12881 # Enable -Werror in bootstrap stage2 and later.
12882 # Check whether --enable-werror or --disable-werror was given.
12883 if test "${enable_werror+set}" = set; then
12884   enableval="$enable_werror"
12885
12886 else
12887   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12888   enable_werror=yes
12889 else
12890   enable_werror=no
12891 fi
12892 fi;
12893 case ${enable_werror} in
12894   yes) stage2_werror_flag="--enable-werror-always" ;;
12895   *) stage2_werror_flag="" ;;
12896 esac
12897
12898
12899 # Flags needed to enable html installing and building
12900
12901 # Check whether --with-datarootdir or --without-datarootdir was given.
12902 if test "${with_datarootdir+set}" = set; then
12903   withval="$with_datarootdir"
12904   datarootdir="\${prefix}/${withval}"
12905 else
12906   datarootdir="\${prefix}/share"
12907 fi;
12908
12909
12910 # Check whether --with-docdir or --without-docdir was given.
12911 if test "${with_docdir+set}" = set; then
12912   withval="$with_docdir"
12913   docdir="\${prefix}/${withval}"
12914 else
12915   docdir="\${datarootdir}/doc"
12916 fi;
12917
12918
12919 # Check whether --with-pdfdir or --without-pdfdir was given.
12920 if test "${with_pdfdir+set}" = set; then
12921   withval="$with_pdfdir"
12922   pdfdir="\${prefix}/${withval}"
12923 else
12924   pdfdir="\${docdir}"
12925 fi;
12926
12927
12928 # Check whether --with-htmldir or --without-htmldir was given.
12929 if test "${with_htmldir+set}" = set; then
12930   withval="$with_htmldir"
12931   htmldir="\${prefix}/${withval}"
12932 else
12933   htmldir="\${docdir}"
12934 fi;
12935
12936
12937
12938
12939
12940
12941 # Specify what files to not compare during bootstrap.
12942
12943 compare_exclusions="gcc/cc*-checksum\$(objext) | gcc/ada/*tools/*"
12944 case "$target" in
12945   hppa*64*-*-hpux*) ;;
12946   hppa*-*-hpux*) compare_exclusions="gcc/cc*-checksum\$(objext) | */libgcc/lib2funcs* | gcc/ada/*tools/*" ;;
12947 esac
12948
12949
12950           ac_config_files="$ac_config_files Makefile"
12951 cat >confcache <<\_ACEOF
12952 # This file is a shell script that caches the results of configure
12953 # tests run on this system so they can be shared between configure
12954 # scripts and configure runs, see configure's option --config-cache.
12955 # It is not useful on other systems.  If it contains results you don't
12956 # want to keep, you may remove or edit it.
12957 #
12958 # config.status only pays attention to the cache file if you give it
12959 # the --recheck option to rerun configure.
12960 #
12961 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12962 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12963 # following values.
12964
12965 _ACEOF
12966
12967 # The following way of writing the cache mishandles newlines in values,
12968 # but we know of no workaround that is simple, portable, and efficient.
12969 # So, don't put newlines in cache variables' values.
12970 # Ultrix sh set writes to stderr and can't be redirected directly,
12971 # and sets the high bit in the cache file unless we assign to the vars.
12972 {
12973   (set) 2>&1 |
12974     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12975     *ac_space=\ *)
12976       # `set' does not quote correctly, so add quotes (double-quote
12977       # substitution turns \\\\ into \\, and sed turns \\ into \).
12978       sed -n \
12979         "s/'/'\\\\''/g;
12980           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12981       ;;
12982     *)
12983       # `set' quotes correctly as required by POSIX, so do not add quotes.
12984       sed -n \
12985         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12986       ;;
12987     esac;
12988 } |
12989   sed '
12990      t clear
12991      : clear
12992      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12993      t end
12994      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12995      : end' >>confcache
12996 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12997   if test -w $cache_file; then
12998     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12999     cat confcache >$cache_file
13000   else
13001     echo "not updating unwritable cache $cache_file"
13002   fi
13003 fi
13004 rm -f confcache
13005
13006 test "x$prefix" = xNONE && prefix=$ac_default_prefix
13007 # Let make expand exec_prefix.
13008 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
13009
13010 # VPATH may cause trouble with some makes, so we remove $(srcdir),
13011 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
13012 # trailing colons and then remove the whole line if VPATH becomes empty
13013 # (actually we leave an empty line to preserve line numbers).
13014 if test "x$srcdir" = x.; then
13015   ac_vpsub='/^[  ]*VPATH[        ]*=/{
13016 s/:*\$(srcdir):*/:/;
13017 s/:*\${srcdir}:*/:/;
13018 s/:*@srcdir@:*/:/;
13019 s/^\([^=]*=[     ]*\):*/\1/;
13020 s/:*$//;
13021 s/^[^=]*=[       ]*$//;
13022 }'
13023 fi
13024
13025 # Transform confdefs.h into DEFS.
13026 # Protect against shell expansion while executing Makefile rules.
13027 # Protect against Makefile macro expansion.
13028 #
13029 # If the first sed substitution is executed (which looks for macros that
13030 # take arguments), then we branch to the quote section.  Otherwise,
13031 # look for a macro that doesn't take arguments.
13032 cat >confdef2opt.sed <<\_ACEOF
13033 t clear
13034 : clear
13035 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
13036 t quote
13037 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
13038 t quote
13039 d
13040 : quote
13041 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
13042 s,\[,\\&,g
13043 s,\],\\&,g
13044 s,\$,$$,g
13045 p
13046 _ACEOF
13047 # We use echo to avoid assuming a particular line-breaking character.
13048 # The extra dot is to prevent the shell from consuming trailing
13049 # line-breaks from the sub-command output.  A line-break within
13050 # single-quotes doesn't work because, if this script is created in a
13051 # platform that uses two characters for line-breaks (e.g., DOS), tr
13052 # would break.
13053 ac_LF_and_DOT=`echo; echo .`
13054 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
13055 rm -f confdef2opt.sed
13056
13057
13058 ac_libobjs=
13059 ac_ltlibobjs=
13060 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
13061   # 1. Remove the extension, and $U if already installed.
13062   ac_i=`echo "$ac_i" |
13063          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
13064   # 2. Add them.
13065   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
13066   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
13067 done
13068 LIBOBJS=$ac_libobjs
13069
13070 LTLIBOBJS=$ac_ltlibobjs
13071
13072
13073
13074 : ${CONFIG_STATUS=./config.status}
13075 ac_clean_files_save=$ac_clean_files
13076 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
13077 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
13078 echo "$as_me: creating $CONFIG_STATUS" >&6;}
13079 cat >$CONFIG_STATUS <<_ACEOF
13080 #! $SHELL
13081 # Generated by $as_me.
13082 # Run this file to recreate the current configuration.
13083 # Compiler output produced by configure, useful for debugging
13084 # configure, is in config.log if it exists.
13085
13086 debug=false
13087 ac_cs_recheck=false
13088 ac_cs_silent=false
13089 SHELL=\${CONFIG_SHELL-$SHELL}
13090 _ACEOF
13091
13092 cat >>$CONFIG_STATUS <<\_ACEOF
13093 ## --------------------- ##
13094 ## M4sh Initialization.  ##
13095 ## --------------------- ##
13096
13097 # Be Bourne compatible
13098 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
13099   emulate sh
13100   NULLCMD=:
13101   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
13102   # is contrary to our usage.  Disable this feature.
13103   alias -g '${1+"$@"}'='"$@"'
13104 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
13105   set -o posix
13106 fi
13107 DUALCASE=1; export DUALCASE # for MKS sh
13108
13109 # Support unset when possible.
13110 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13111   as_unset=unset
13112 else
13113   as_unset=false
13114 fi
13115
13116
13117 # Work around bugs in pre-3.0 UWIN ksh.
13118 $as_unset ENV MAIL MAILPATH
13119 PS1='$ '
13120 PS2='> '
13121 PS4='+ '
13122
13123 # NLS nuisances.
13124 for as_var in \
13125   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13126   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13127   LC_TELEPHONE LC_TIME
13128 do
13129   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13130     eval $as_var=C; export $as_var
13131   else
13132     $as_unset $as_var
13133   fi
13134 done
13135
13136 # Required to use basename.
13137 if expr a : '\(a\)' >/dev/null 2>&1; then
13138   as_expr=expr
13139 else
13140   as_expr=false
13141 fi
13142
13143 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13144   as_basename=basename
13145 else
13146   as_basename=false
13147 fi
13148
13149
13150 # Name of the executable.
13151 as_me=`$as_basename "$0" ||
13152 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13153          X"$0" : 'X\(//\)$' \| \
13154          X"$0" : 'X\(/\)$' \| \
13155          .     : '\(.\)' 2>/dev/null ||
13156 echo X/"$0" |
13157     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13158           /^X\/\(\/\/\)$/{ s//\1/; q; }
13159           /^X\/\(\/\).*/{ s//\1/; q; }
13160           s/.*/./; q'`
13161
13162
13163 # PATH needs CR, and LINENO needs CR and PATH.
13164 # Avoid depending upon Character Ranges.
13165 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13166 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13167 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13168 as_cr_digits='0123456789'
13169 as_cr_alnum=$as_cr_Letters$as_cr_digits
13170
13171 # The user is always right.
13172 if test "${PATH_SEPARATOR+set}" != set; then
13173   echo "#! /bin/sh" >conf$$.sh
13174   echo  "exit 0"   >>conf$$.sh
13175   chmod +x conf$$.sh
13176   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13177     PATH_SEPARATOR=';'
13178   else
13179     PATH_SEPARATOR=:
13180   fi
13181   rm -f conf$$.sh
13182 fi
13183
13184
13185   as_lineno_1=$LINENO
13186   as_lineno_2=$LINENO
13187   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13188   test "x$as_lineno_1" != "x$as_lineno_2" &&
13189   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13190   # Find who we are.  Look in the path if we contain no path at all
13191   # relative or not.
13192   case $0 in
13193     *[\\/]* ) as_myself=$0 ;;
13194     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13195 for as_dir in $PATH
13196 do
13197   IFS=$as_save_IFS
13198   test -z "$as_dir" && as_dir=.
13199   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13200 done
13201
13202        ;;
13203   esac
13204   # We did not find ourselves, most probably we were run as `sh COMMAND'
13205   # in which case we are not to be found in the path.
13206   if test "x$as_myself" = x; then
13207     as_myself=$0
13208   fi
13209   if test ! -f "$as_myself"; then
13210     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13211 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13212    { (exit 1); exit 1; }; }
13213   fi
13214   case $CONFIG_SHELL in
13215   '')
13216     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13217 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13218 do
13219   IFS=$as_save_IFS
13220   test -z "$as_dir" && as_dir=.
13221   for as_base in sh bash ksh sh5; do
13222          case $as_dir in
13223          /*)
13224            if ("$as_dir/$as_base" -c '
13225   as_lineno_1=$LINENO
13226   as_lineno_2=$LINENO
13227   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13228   test "x$as_lineno_1" != "x$as_lineno_2" &&
13229   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13230              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13231              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13232              CONFIG_SHELL=$as_dir/$as_base
13233              export CONFIG_SHELL
13234              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13235            fi;;
13236          esac
13237        done
13238 done
13239 ;;
13240   esac
13241
13242   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13243   # uniformly replaced by the line number.  The first 'sed' inserts a
13244   # line-number line before each line; the second 'sed' does the real
13245   # work.  The second script uses 'N' to pair each line-number line
13246   # with the numbered line, and appends trailing '-' during
13247   # substitution so that $LINENO is not a special case at line end.
13248   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13249   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13250   sed '=' <$as_myself |
13251     sed '
13252       N
13253       s,$,-,
13254       : loop
13255       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13256       t loop
13257       s,-$,,
13258       s,^['$as_cr_digits']*\n,,
13259     ' >$as_me.lineno &&
13260   chmod +x $as_me.lineno ||
13261     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13262 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13263    { (exit 1); exit 1; }; }
13264
13265   # Don't try to exec as it changes $[0], causing all sort of problems
13266   # (the dirname of $[0] is not the place where we might find the
13267   # original and so on.  Autoconf is especially sensible to this).
13268   . ./$as_me.lineno
13269   # Exit status is that of the last command.
13270   exit
13271 }
13272
13273
13274 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13275   *c*,-n*) ECHO_N= ECHO_C='
13276 ' ECHO_T='      ' ;;
13277   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13278   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13279 esac
13280
13281 if expr a : '\(a\)' >/dev/null 2>&1; then
13282   as_expr=expr
13283 else
13284   as_expr=false
13285 fi
13286
13287 rm -f conf$$ conf$$.exe conf$$.file
13288 echo >conf$$.file
13289 if ln -s conf$$.file conf$$ 2>/dev/null; then
13290   # We could just check for DJGPP; but this test a) works b) is more generic
13291   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13292   if test -f conf$$.exe; then
13293     # Don't use ln at all; we don't have any links
13294     as_ln_s='cp -p'
13295   else
13296     as_ln_s='ln -s'
13297   fi
13298 elif ln conf$$.file conf$$ 2>/dev/null; then
13299   as_ln_s=ln
13300 else
13301   as_ln_s='cp -p'
13302 fi
13303 rm -f conf$$ conf$$.exe conf$$.file
13304
13305 if mkdir -p . 2>/dev/null; then
13306   as_mkdir_p=:
13307 else
13308   test -d ./-p && rmdir ./-p
13309   as_mkdir_p=false
13310 fi
13311
13312 as_executable_p="test -f"
13313
13314 # Sed expression to map a string onto a valid CPP name.
13315 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13316
13317 # Sed expression to map a string onto a valid variable name.
13318 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13319
13320
13321 # IFS
13322 # We need space, tab and new line, in precisely that order.
13323 as_nl='
13324 '
13325 IFS="   $as_nl"
13326
13327 # CDPATH.
13328 $as_unset CDPATH
13329
13330 exec 6>&1
13331
13332 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13333 # report actual input values of CONFIG_FILES etc. instead of their
13334 # values after options handling.  Logging --version etc. is OK.
13335 exec 5>>config.log
13336 {
13337   echo
13338   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13339 ## Running $as_me. ##
13340 _ASBOX
13341 } >&5
13342 cat >&5 <<_CSEOF
13343
13344 This file was extended by $as_me, which was
13345 generated by GNU Autoconf 2.59.  Invocation command line was
13346
13347   CONFIG_FILES    = $CONFIG_FILES
13348   CONFIG_HEADERS  = $CONFIG_HEADERS
13349   CONFIG_LINKS    = $CONFIG_LINKS
13350   CONFIG_COMMANDS = $CONFIG_COMMANDS
13351   $ $0 $@
13352
13353 _CSEOF
13354 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13355 echo >&5
13356 _ACEOF
13357
13358 # Files that config.status was made for.
13359 if test -n "$ac_config_files"; then
13360   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13361 fi
13362
13363 if test -n "$ac_config_headers"; then
13364   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13365 fi
13366
13367 if test -n "$ac_config_links"; then
13368   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13369 fi
13370
13371 if test -n "$ac_config_commands"; then
13372   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13373 fi
13374
13375 cat >>$CONFIG_STATUS <<\_ACEOF
13376
13377 ac_cs_usage="\
13378 \`$as_me' instantiates files from templates according to the
13379 current configuration.
13380
13381 Usage: $0 [OPTIONS] [FILE]...
13382
13383   -h, --help       print this help, then exit
13384   -V, --version    print version number, then exit
13385   -q, --quiet      do not print progress messages
13386   -d, --debug      don't remove temporary files
13387       --recheck    update $as_me by reconfiguring in the same conditions
13388   --file=FILE[:TEMPLATE]
13389                    instantiate the configuration file FILE
13390
13391 Configuration files:
13392 $config_files
13393
13394 Report bugs to <bug-autoconf@gnu.org>."
13395 _ACEOF
13396
13397 cat >>$CONFIG_STATUS <<_ACEOF
13398 ac_cs_version="\\
13399 config.status
13400 configured by $0, generated by GNU Autoconf 2.59,
13401   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13402
13403 Copyright (C) 2003 Free Software Foundation, Inc.
13404 This config.status script is free software; the Free Software Foundation
13405 gives unlimited permission to copy, distribute and modify it."
13406 srcdir=$srcdir
13407 INSTALL="$INSTALL"
13408 _ACEOF
13409
13410 cat >>$CONFIG_STATUS <<\_ACEOF
13411 # If no file are specified by the user, then we need to provide default
13412 # value.  By we need to know if files were specified by the user.
13413 ac_need_defaults=:
13414 while test $# != 0
13415 do
13416   case $1 in
13417   --*=*)
13418     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13419     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13420     ac_shift=:
13421     ;;
13422   -*)
13423     ac_option=$1
13424     ac_optarg=$2
13425     ac_shift=shift
13426     ;;
13427   *) # This is not an option, so the user has probably given explicit
13428      # arguments.
13429      ac_option=$1
13430      ac_need_defaults=false;;
13431   esac
13432
13433   case $ac_option in
13434   # Handling of the options.
13435 _ACEOF
13436 cat >>$CONFIG_STATUS <<\_ACEOF
13437   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13438     ac_cs_recheck=: ;;
13439   --version | --vers* | -V )
13440     echo "$ac_cs_version"; exit 0 ;;
13441   --he | --h)
13442     # Conflict between --help and --header
13443     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13444 Try \`$0 --help' for more information." >&5
13445 echo "$as_me: error: ambiguous option: $1
13446 Try \`$0 --help' for more information." >&2;}
13447    { (exit 1); exit 1; }; };;
13448   --help | --hel | -h )
13449     echo "$ac_cs_usage"; exit 0 ;;
13450   --debug | --d* | -d )
13451     debug=: ;;
13452   --file | --fil | --fi | --f )
13453     $ac_shift
13454     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13455     ac_need_defaults=false;;
13456   --header | --heade | --head | --hea )
13457     $ac_shift
13458     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13459     ac_need_defaults=false;;
13460   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13461   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13462     ac_cs_silent=: ;;
13463
13464   # This is an error.
13465   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13466 Try \`$0 --help' for more information." >&5
13467 echo "$as_me: error: unrecognized option: $1
13468 Try \`$0 --help' for more information." >&2;}
13469    { (exit 1); exit 1; }; } ;;
13470
13471   *) ac_config_targets="$ac_config_targets $1" ;;
13472
13473   esac
13474   shift
13475 done
13476
13477 ac_configure_extra_args=
13478
13479 if $ac_cs_silent; then
13480   exec 6>/dev/null
13481   ac_configure_extra_args="$ac_configure_extra_args --silent"
13482 fi
13483
13484 _ACEOF
13485 cat >>$CONFIG_STATUS <<_ACEOF
13486 if \$ac_cs_recheck; then
13487   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13488   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13489 fi
13490
13491 _ACEOF
13492
13493
13494
13495
13496
13497 cat >>$CONFIG_STATUS <<\_ACEOF
13498 for ac_config_target in $ac_config_targets
13499 do
13500   case "$ac_config_target" in
13501   # Handling of arguments.
13502   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13503   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13504 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13505    { (exit 1); exit 1; }; };;
13506   esac
13507 done
13508
13509 # If the user did not use the arguments to specify the items to instantiate,
13510 # then the envvar interface is used.  Set only those that are not.
13511 # We use the long form for the default assignment because of an extremely
13512 # bizarre bug on SunOS 4.1.3.
13513 if $ac_need_defaults; then
13514   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13515 fi
13516
13517 # Have a temporary directory for convenience.  Make it in the build tree
13518 # simply because there is no reason to put it here, and in addition,
13519 # creating and moving files from /tmp can sometimes cause problems.
13520 # Create a temporary directory, and hook for its removal unless debugging.
13521 $debug ||
13522 {
13523   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13524   trap '{ (exit 1); exit 1; }' 1 2 13 15
13525 }
13526
13527 # Create a (secure) tmp directory for tmp files.
13528
13529 {
13530   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13531   test -n "$tmp" && test -d "$tmp"
13532 }  ||
13533 {
13534   tmp=./confstat$$-$RANDOM
13535   (umask 077 && mkdir $tmp)
13536 } ||
13537 {
13538    echo "$me: cannot create a temporary directory in ." >&2
13539    { (exit 1); exit 1; }
13540 }
13541
13542 _ACEOF
13543
13544 cat >>$CONFIG_STATUS <<_ACEOF
13545
13546 #
13547 # CONFIG_FILES section.
13548 #
13549
13550 # No need to generate the scripts if there are no CONFIG_FILES.
13551 # This happens for instance when ./config.status config.h
13552 if test -n "\$CONFIG_FILES"; then
13553   # Protect against being on the right side of a sed subst in config.status.
13554   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13555    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13556 s,@SHELL@,$SHELL,;t t
13557 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13558 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13559 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13560 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13561 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13562 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13563 s,@exec_prefix@,$exec_prefix,;t t
13564 s,@prefix@,$prefix,;t t
13565 s,@program_transform_name@,$program_transform_name,;t t
13566 s,@bindir@,$bindir,;t t
13567 s,@sbindir@,$sbindir,;t t
13568 s,@libexecdir@,$libexecdir,;t t
13569 s,@datadir@,$datadir,;t t
13570 s,@sysconfdir@,$sysconfdir,;t t
13571 s,@sharedstatedir@,$sharedstatedir,;t t
13572 s,@localstatedir@,$localstatedir,;t t
13573 s,@libdir@,$libdir,;t t
13574 s,@includedir@,$includedir,;t t
13575 s,@oldincludedir@,$oldincludedir,;t t
13576 s,@infodir@,$infodir,;t t
13577 s,@mandir@,$mandir,;t t
13578 s,@build_alias@,$build_alias,;t t
13579 s,@host_alias@,$host_alias,;t t
13580 s,@target_alias@,$target_alias,;t t
13581 s,@DEFS@,$DEFS,;t t
13582 s,@ECHO_C@,$ECHO_C,;t t
13583 s,@ECHO_N@,$ECHO_N,;t t
13584 s,@ECHO_T@,$ECHO_T,;t t
13585 s,@LIBS@,$LIBS,;t t
13586 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13587 s,@build@,$build,;t t
13588 s,@build_cpu@,$build_cpu,;t t
13589 s,@build_vendor@,$build_vendor,;t t
13590 s,@build_os@,$build_os,;t t
13591 s,@build_noncanonical@,$build_noncanonical,;t t
13592 s,@host_noncanonical@,$host_noncanonical,;t t
13593 s,@target_noncanonical@,$target_noncanonical,;t t
13594 s,@host@,$host,;t t
13595 s,@host_cpu@,$host_cpu,;t t
13596 s,@host_vendor@,$host_vendor,;t t
13597 s,@host_os@,$host_os,;t t
13598 s,@target@,$target,;t t
13599 s,@target_cpu@,$target_cpu,;t t
13600 s,@target_vendor@,$target_vendor,;t t
13601 s,@target_os@,$target_os,;t t
13602 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13603 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13604 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13605 s,@LN@,$LN,;t t
13606 s,@LN_S@,$LN_S,;t t
13607 s,@build_libsubdir@,$build_libsubdir,;t t
13608 s,@build_subdir@,$build_subdir,;t t
13609 s,@host_subdir@,$host_subdir,;t t
13610 s,@target_subdir@,$target_subdir,;t t
13611 s,@CC@,$CC,;t t
13612 s,@CFLAGS@,$CFLAGS,;t t
13613 s,@LDFLAGS@,$LDFLAGS,;t t
13614 s,@CPPFLAGS@,$CPPFLAGS,;t t
13615 s,@ac_ct_CC@,$ac_ct_CC,;t t
13616 s,@EXEEXT@,$EXEEXT,;t t
13617 s,@OBJEXT@,$OBJEXT,;t t
13618 s,@CXX@,$CXX,;t t
13619 s,@CXXFLAGS@,$CXXFLAGS,;t t
13620 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13621 s,@GNATBIND@,$GNATBIND,;t t
13622 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13623 s,@GNATMAKE@,$GNATMAKE,;t t
13624 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13625 s,@do_compare@,$do_compare,;t t
13626 s,@gmplibs@,$gmplibs,;t t
13627 s,@gmpinc@,$gmpinc,;t t
13628 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13629 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13630 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13631 s,@stage1_ldflags@,$stage1_ldflags,;t t
13632 s,@stage1_libs@,$stage1_libs,;t t
13633 s,@poststage1_ldflags@,$poststage1_ldflags,;t t
13634 s,@poststage1_libs@,$poststage1_libs,;t t
13635 s,@ppllibs@,$ppllibs,;t t
13636 s,@pplinc@,$pplinc,;t t
13637 s,@clooglibs@,$clooglibs,;t t
13638 s,@clooginc@,$clooginc,;t t
13639 s,@stage1_languages@,$stage1_languages,;t t
13640 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13641 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13642 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13643 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13644 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13645 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13646 s,@tooldir@,$tooldir,;t t
13647 s,@build_tooldir@,$build_tooldir,;t t
13648 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13649 s,@GDB_TK@,$GDB_TK,;t t
13650 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13651 s,@build_configargs@,$build_configargs,;t t
13652 s,@build_configdirs@,$build_configdirs,;t t
13653 s,@host_configargs@,$host_configargs,;t t
13654 s,@configdirs@,$configdirs,;t t
13655 s,@target_configargs@,$target_configargs,;t t
13656 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13657 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13658 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13659 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13660 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13661 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13662 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13663 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13664 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13665 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13666 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13667 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13668 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13669 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13670 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13671 s,@config_shell@,$config_shell,;t t
13672 s,@YACC@,$YACC,;t t
13673 s,@BISON@,$BISON,;t t
13674 s,@M4@,$M4,;t t
13675 s,@LEX@,$LEX,;t t
13676 s,@FLEX@,$FLEX,;t t
13677 s,@MAKEINFO@,$MAKEINFO,;t t
13678 s,@EXPECT@,$EXPECT,;t t
13679 s,@RUNTEST@,$RUNTEST,;t t
13680 s,@AR@,$AR,;t t
13681 s,@AS@,$AS,;t t
13682 s,@DLLTOOL@,$DLLTOOL,;t t
13683 s,@LD@,$LD,;t t
13684 s,@LIPO@,$LIPO,;t t
13685 s,@NM@,$NM,;t t
13686 s,@RANLIB@,$RANLIB,;t t
13687 s,@STRIP@,$STRIP,;t t
13688 s,@WINDRES@,$WINDRES,;t t
13689 s,@WINDMC@,$WINDMC,;t t
13690 s,@OBJCOPY@,$OBJCOPY,;t t
13691 s,@OBJDUMP@,$OBJDUMP,;t t
13692 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13693 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13694 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13695 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13696 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13697 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13698 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13699 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13700 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13701 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13702 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13703 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13704 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13705 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13706 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13707 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13708 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13709 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13710 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13711 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13712 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13713 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13714 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13715 s,@MAINT@,$MAINT,;t t
13716 s,@stage1_cflags@,$stage1_cflags,;t t
13717 s,@stage1_checking@,$stage1_checking,;t t
13718 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13719 s,@datarootdir@,$datarootdir,;t t
13720 s,@docdir@,$docdir,;t t
13721 s,@pdfdir@,$pdfdir,;t t
13722 s,@htmldir@,$htmldir,;t t
13723 s,@compare_exclusions@,$compare_exclusions,;t t
13724 s,@LIBOBJS@,$LIBOBJS,;t t
13725 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13726 /@serialization_dependencies@/r $serialization_dependencies
13727 s,@serialization_dependencies@,,;t t
13728 /@host_makefile_frag@/r $host_makefile_frag
13729 s,@host_makefile_frag@,,;t t
13730 /@target_makefile_frag@/r $target_makefile_frag
13731 s,@target_makefile_frag@,,;t t
13732 /@alphaieee_frag@/r $alphaieee_frag
13733 s,@alphaieee_frag@,,;t t
13734 /@ospace_frag@/r $ospace_frag
13735 s,@ospace_frag@,,;t t
13736 CEOF
13737
13738 _ACEOF
13739
13740   cat >>$CONFIG_STATUS <<\_ACEOF
13741   # Split the substitutions into bite-sized pieces for seds with
13742   # small command number limits, like on Digital OSF/1 and HP-UX.
13743   ac_max_sed_lines=48
13744   ac_sed_frag=1 # Number of current file.
13745   ac_beg=1 # First line for current file.
13746   ac_end=$ac_max_sed_lines # Line after last line for current file.
13747   ac_more_lines=:
13748   ac_sed_cmds=
13749   while $ac_more_lines; do
13750     if test $ac_beg -gt 1; then
13751       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13752     else
13753       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13754     fi
13755     if test ! -s $tmp/subs.frag; then
13756       ac_more_lines=false
13757     else
13758       # The purpose of the label and of the branching condition is to
13759       # speed up the sed processing (if there are no `@' at all, there
13760       # is no need to browse any of the substitutions).
13761       # These are the two extra sed commands mentioned above.
13762       (echo ':t
13763   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13764       if test -z "$ac_sed_cmds"; then
13765         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13766       else
13767         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13768       fi
13769       ac_sed_frag=`expr $ac_sed_frag + 1`
13770       ac_beg=$ac_end
13771       ac_end=`expr $ac_end + $ac_max_sed_lines`
13772     fi
13773   done
13774   if test -z "$ac_sed_cmds"; then
13775     ac_sed_cmds=cat
13776   fi
13777 fi # test -n "$CONFIG_FILES"
13778
13779 _ACEOF
13780 cat >>$CONFIG_STATUS <<\_ACEOF
13781 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13782   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13783   case $ac_file in
13784   - | *:- | *:-:* ) # input from stdin
13785         cat >$tmp/stdin
13786         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13787         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13788   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13789         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13790   * )   ac_file_in=$ac_file.in ;;
13791   esac
13792
13793   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13794   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13795 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13796          X"$ac_file" : 'X\(//\)[^/]' \| \
13797          X"$ac_file" : 'X\(//\)$' \| \
13798          X"$ac_file" : 'X\(/\)' \| \
13799          .     : '\(.\)' 2>/dev/null ||
13800 echo X"$ac_file" |
13801     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13802           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13803           /^X\(\/\/\)$/{ s//\1/; q; }
13804           /^X\(\/\).*/{ s//\1/; q; }
13805           s/.*/./; q'`
13806   { if $as_mkdir_p; then
13807     mkdir -p "$ac_dir"
13808   else
13809     as_dir="$ac_dir"
13810     as_dirs=
13811     while test ! -d "$as_dir"; do
13812       as_dirs="$as_dir $as_dirs"
13813       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13814 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13815          X"$as_dir" : 'X\(//\)[^/]' \| \
13816          X"$as_dir" : 'X\(//\)$' \| \
13817          X"$as_dir" : 'X\(/\)' \| \
13818          .     : '\(.\)' 2>/dev/null ||
13819 echo X"$as_dir" |
13820     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13821           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13822           /^X\(\/\/\)$/{ s//\1/; q; }
13823           /^X\(\/\).*/{ s//\1/; q; }
13824           s/.*/./; q'`
13825     done
13826     test ! -n "$as_dirs" || mkdir $as_dirs
13827   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13828 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13829    { (exit 1); exit 1; }; }; }
13830
13831   ac_builddir=.
13832
13833 if test "$ac_dir" != .; then
13834   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13835   # A "../" for each directory in $ac_dir_suffix.
13836   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13837 else
13838   ac_dir_suffix= ac_top_builddir=
13839 fi
13840
13841 case $srcdir in
13842   .)  # No --srcdir option.  We are building in place.
13843     ac_srcdir=.
13844     if test -z "$ac_top_builddir"; then
13845        ac_top_srcdir=.
13846     else
13847        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13848     fi ;;
13849   [\\/]* | ?:[\\/]* )  # Absolute path.
13850     ac_srcdir=$srcdir$ac_dir_suffix;
13851     ac_top_srcdir=$srcdir ;;
13852   *) # Relative path.
13853     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13854     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13855 esac
13856
13857 # Do not use `cd foo && pwd` to compute absolute paths, because
13858 # the directories may not exist.
13859 case `pwd` in
13860 .) ac_abs_builddir="$ac_dir";;
13861 *)
13862   case "$ac_dir" in
13863   .) ac_abs_builddir=`pwd`;;
13864   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13865   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13866   esac;;
13867 esac
13868 case $ac_abs_builddir in
13869 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13870 *)
13871   case ${ac_top_builddir}. in
13872   .) ac_abs_top_builddir=$ac_abs_builddir;;
13873   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13874   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13875   esac;;
13876 esac
13877 case $ac_abs_builddir in
13878 .) ac_abs_srcdir=$ac_srcdir;;
13879 *)
13880   case $ac_srcdir in
13881   .) ac_abs_srcdir=$ac_abs_builddir;;
13882   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13883   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13884   esac;;
13885 esac
13886 case $ac_abs_builddir in
13887 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13888 *)
13889   case $ac_top_srcdir in
13890   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13891   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13892   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13893   esac;;
13894 esac
13895
13896
13897   case $INSTALL in
13898   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13899   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13900   esac
13901
13902   if test x"$ac_file" != x-; then
13903     { echo "$as_me:$LINENO: creating $ac_file" >&5
13904 echo "$as_me: creating $ac_file" >&6;}
13905     rm -f "$ac_file"
13906   fi
13907   # Let's still pretend it is `configure' which instantiates (i.e., don't
13908   # use $as_me), people would be surprised to read:
13909   #    /* config.h.  Generated by config.status.  */
13910   if test x"$ac_file" = x-; then
13911     configure_input=
13912   else
13913     configure_input="$ac_file.  "
13914   fi
13915   configure_input=$configure_input"Generated from `echo $ac_file_in |
13916                                      sed 's,.*/,,'` by configure."
13917
13918   # First look for the input files in the build tree, otherwise in the
13919   # src tree.
13920   ac_file_inputs=`IFS=:
13921     for f in $ac_file_in; do
13922       case $f in
13923       -) echo $tmp/stdin ;;
13924       [\\/$]*)
13925          # Absolute (can't be DOS-style, as IFS=:)
13926          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13927 echo "$as_me: error: cannot find input file: $f" >&2;}
13928    { (exit 1); exit 1; }; }
13929          echo "$f";;
13930       *) # Relative
13931          if test -f "$f"; then
13932            # Build tree
13933            echo "$f"
13934          elif test -f "$srcdir/$f"; then
13935            # Source tree
13936            echo "$srcdir/$f"
13937          else
13938            # /dev/null tree
13939            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13940 echo "$as_me: error: cannot find input file: $f" >&2;}
13941    { (exit 1); exit 1; }; }
13942          fi;;
13943       esac
13944     done` || { (exit 1); exit 1; }
13945 _ACEOF
13946 cat >>$CONFIG_STATUS <<_ACEOF
13947   sed "$ac_vpsub
13948 $extrasub
13949 _ACEOF
13950 cat >>$CONFIG_STATUS <<\_ACEOF
13951 :t
13952 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13953 s,@configure_input@,$configure_input,;t t
13954 s,@srcdir@,$ac_srcdir,;t t
13955 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13956 s,@top_srcdir@,$ac_top_srcdir,;t t
13957 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13958 s,@builddir@,$ac_builddir,;t t
13959 s,@abs_builddir@,$ac_abs_builddir,;t t
13960 s,@top_builddir@,$ac_top_builddir,;t t
13961 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13962 s,@INSTALL@,$ac_INSTALL,;t t
13963 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13964   rm -f $tmp/stdin
13965   if test x"$ac_file" != x-; then
13966     mv $tmp/out $ac_file
13967   else
13968     cat $tmp/out
13969     rm -f $tmp/out
13970   fi
13971
13972 done
13973 _ACEOF
13974
13975 cat >>$CONFIG_STATUS <<\_ACEOF
13976
13977 { (exit 0); exit 0; }
13978 _ACEOF
13979 chmod +x $CONFIG_STATUS
13980 ac_clean_files=$ac_clean_files_save
13981
13982
13983 # configure is writing to config.log, and then calls config.status.
13984 # config.status does its own redirection, appending to config.log.
13985 # Unfortunately, on DOS this fails, as config.log is still kept open
13986 # by configure, so config.status won't be able to write to it; its
13987 # output is simply discarded.  So we exec the FD to /dev/null,
13988 # effectively closing config.log, so it can be properly (re)opened and
13989 # appended to by config.status.  When coming back to configure, we
13990 # need to make the FD available again.
13991 if test "$no_create" != yes; then
13992   ac_cs_success=:
13993   ac_config_status_args=
13994   test "$silent" = yes &&
13995     ac_config_status_args="$ac_config_status_args --quiet"
13996   exec 5>/dev/null
13997   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13998   exec 5>>config.log
13999   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
14000   # would make configure fail if this is the last instruction.
14001   $ac_cs_success || { (exit 1); exit 1; }
14002 fi
14003