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 stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET CPPFLAGS_FOR_TARGET LDFLAGS_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 CPPFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-stage1-languages[=all]   choose additional languages to build during
 939                           stage1.  Mostly useful for compiler development.
 940   --enable-objc-gc        enable use of Boehm's garbage collector with the
 941                           GNU Objective-C runtime
 942   --enable-bootstrap      enable bootstrapping [yes if native build]
 943   --enable-serial-[{host,target,build}-]configure
 944                           force sequential configuration of
 945                           sub-packages for the host, target or build
 946                           machine, or all sub-packages
 947   --enable-maintainer-mode enable make rules and dependencies not useful
 948                           (and sometimes confusing) to the casual installer
 949   --enable-stage1-checking[=all]   choose additional checking for stage1
 950                           of the compiler
 951   --enable-werror         enable -Werror in bootstrap stage2 and later
 952
 953 Optional Packages:
 954   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 955   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 956   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 957   --with-mpfr-dir=PATH    this option has been REMOVED
 958   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 959                           Equivalent to --with-mpfr-include=PATH/include
 960                           plus --with-mpfr-lib=PATH/lib
 961   --with-mpfr-include=PATH
 962                           specify directory for installed MPFR include files
 963   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 964   --with-gmp-dir=PATH     this option has been REMOVED
 965   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 966                           Equivalent to --with-gmp-include=PATH/include
 967                           plus --with-gmp-lib=PATH/lib
 968   --with-gmp-include=PATH specify directory for installed GMP include files
 969   --with-gmp-lib=PATH     specify directory for the installed GMP library
 970   --with-build-sysroot=SYSROOT
 971                           use sysroot as the system root during the build
 972   --with-debug-prefix-map='A=B C=D ...'
 973                              map A to B, C to D ... in debug information
 974   --with-build-time-tools=PATH
 975                           use given path to find target tools during the build
 976   --with-datarootdir      use datarootdir as the data root directory.
 977   --with-docdir           install documentation in this directory.
 978   --with-pdfdir           install pdf in this directory.
 979   --with-htmldir          install html in this directory.
 980
 981 Some influential environment variables:
 982   CC          C compiler command
 983   CFLAGS      C compiler flags
 984   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 985               nonstandard directory <lib dir>
 986   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 987               headers in a nonstandard directory <include dir>
 988   CXX         C++ compiler command
 989   CXXFLAGS    C++ compiler flags
 990   AR          AR for the host
 991   AS          AS for the host
 992   DLLTOOL     DLLTOOL for the host
 993   LD          LD for the host
 994   LIPO        LIPO for the host
 995   NM          NM for the host
 996   RANLIB      RANLIB for the host
 997   STRIP       STRIP for the host
 998   WINDRES     WINDRES for the host
 999   WINDMC      WINDMC for the host
1000   OBJCOPY     OBJCOPY for the host
1001   OBJDUMP     OBJDUMP for the host
1002   CC_FOR_TARGET
1003               CC for the target
1004   CXX_FOR_TARGET
1005               CXX for the target
1006   GCC_FOR_TARGET
1007               GCC for the target
1008   GCJ_FOR_TARGET
1009               GCJ for the target
1010   GFORTRAN_FOR_TARGET
1011               GFORTRAN for the target
1012   AR_FOR_TARGET
1013               AR for the target
1014   AS_FOR_TARGET
1015               AS for the target
1016   DLLTOOL_FOR_TARGET
1017               DLLTOOL for the target
1018   LD_FOR_TARGET
1019               LD for the target
1020   LIPO_FOR_TARGET
1021               LIPO for the target
1022   NM_FOR_TARGET
1023               NM for the target
1024   OBJDUMP_FOR_TARGET
1025               OBJDUMP for the target
1026   RANLIB_FOR_TARGET
1027               RANLIB for the target
1028   STRIP_FOR_TARGET
1029               STRIP for the target
1030   WINDRES_FOR_TARGET
1031               WINDRES for the target
1032   WINDMC_FOR_TARGET
1033               WINDMC for the target
1034
1035 Use these variables to override the choices made by `configure' or to help
1036 it to find libraries and programs with nonstandard names/locations.
1037
1038 _ACEOF
1039 fi
1040
1041 if test "$ac_init_help" = "recursive"; then
1042   # If there are subdirs, report their specific --help.
1043   ac_popdir=`pwd`
1044   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1045     test -d $ac_dir || continue
1046     ac_builddir=.
1047
1048 if test "$ac_dir" != .; then
1049   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1050   # A "../" for each directory in $ac_dir_suffix.
1051   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1052 else
1053   ac_dir_suffix= ac_top_builddir=
1054 fi
1055
1056 case $srcdir in
1057   .)  # No --srcdir option.  We are building in place.
1058     ac_srcdir=.
1059     if test -z "$ac_top_builddir"; then
1060        ac_top_srcdir=.
1061     else
1062        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1063     fi ;;
1064   [\\/]* | ?:[\\/]* )  # Absolute path.
1065     ac_srcdir=$srcdir$ac_dir_suffix;
1066     ac_top_srcdir=$srcdir ;;
1067   *) # Relative path.
1068     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1069     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1070 esac
1071
1072 # Do not use `cd foo && pwd` to compute absolute paths, because
1073 # the directories may not exist.
1074 case `pwd` in
1075 .) ac_abs_builddir="$ac_dir";;
1076 *)
1077   case "$ac_dir" in
1078   .) ac_abs_builddir=`pwd`;;
1079   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1080   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1081   esac;;
1082 esac
1083 case $ac_abs_builddir in
1084 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1085 *)
1086   case ${ac_top_builddir}. in
1087   .) ac_abs_top_builddir=$ac_abs_builddir;;
1088   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1089   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1090   esac;;
1091 esac
1092 case $ac_abs_builddir in
1093 .) ac_abs_srcdir=$ac_srcdir;;
1094 *)
1095   case $ac_srcdir in
1096   .) ac_abs_srcdir=$ac_abs_builddir;;
1097   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1098   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1099   esac;;
1100 esac
1101 case $ac_abs_builddir in
1102 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1103 *)
1104   case $ac_top_srcdir in
1105   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1106   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1107   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1108   esac;;
1109 esac
1110
1111     cd $ac_dir
1112     # Check for guested configure; otherwise get Cygnus style configure.
1113     if test -f $ac_srcdir/configure.gnu; then
1114       echo
1115       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1116     elif test -f $ac_srcdir/configure; then
1117       echo
1118       $SHELL $ac_srcdir/configure  --help=recursive
1119     elif test -f $ac_srcdir/configure.ac ||
1120            test -f $ac_srcdir/configure.in; then
1121       echo
1122       $ac_configure --help
1123     else
1124       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1125     fi
1126     cd $ac_popdir
1127   done
1128 fi
1129
1130 test -n "$ac_init_help" && exit 0
1131 if $ac_init_version; then
1132   cat <<\_ACEOF
1133
1134 Copyright (C) 2003 Free Software Foundation, Inc.
1135 This configure script is free software; the Free Software Foundation
1136 gives unlimited permission to copy, distribute and modify it.
1137 _ACEOF
1138   exit 0
1139 fi
1140 exec 5>config.log
1141 cat >&5 <<_ACEOF
1142 This file contains any messages produced by compilers while
1143 running configure, to aid debugging if configure makes a mistake.
1144
1145 It was created by $as_me, which was
1146 generated by GNU Autoconf 2.59.  Invocation command line was
1147
1148   $ $0 $@
1149
1150 _ACEOF
1151 {
1152 cat <<_ASUNAME
1153 ## --------- ##
1154 ## Platform. ##
1155 ## --------- ##
1156
1157 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1158 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1159 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1160 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1161 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1162
1163 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1164 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1165
1166 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1167 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1168 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1169 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1170 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1171 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1172 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1173
1174 _ASUNAME
1175
1176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1177 for as_dir in $PATH
1178 do
1179   IFS=$as_save_IFS
1180   test -z "$as_dir" && as_dir=.
1181   echo "PATH: $as_dir"
1182 done
1183
1184 } >&5
1185
1186 cat >&5 <<_ACEOF
1187
1188
1189 ## ----------- ##
1190 ## Core tests. ##
1191 ## ----------- ##
1192
1193 _ACEOF
1194
1195
1196 # Keep a trace of the command line.
1197 # Strip out --no-create and --no-recursion so they do not pile up.
1198 # Strip out --silent because we don't want to record it for future runs.
1199 # Also quote any args containing shell meta-characters.
1200 # Make two passes to allow for proper duplicate-argument suppression.
1201 ac_configure_args=
1202 ac_configure_args0=
1203 ac_configure_args1=
1204 ac_sep=
1205 ac_must_keep_next=false
1206 for ac_pass in 1 2
1207 do
1208   for ac_arg
1209   do
1210     case $ac_arg in
1211     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1212     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1213     | -silent | --silent | --silen | --sile | --sil)
1214       continue ;;
1215     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1216       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1217     esac
1218     case $ac_pass in
1219     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1220     2)
1221       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1222       if test $ac_must_keep_next = true; then
1223         ac_must_keep_next=false # Got value, back to normal.
1224       else
1225         case $ac_arg in
1226           *=* | --config-cache | -C | -disable-* | --disable-* \
1227           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1228           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1229           | -with-* | --with-* | -without-* | --without-* | --x)
1230             case "$ac_configure_args0 " in
1231               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1232             esac
1233             ;;
1234           -* ) ac_must_keep_next=true ;;
1235         esac
1236       fi
1237       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1238       # Get rid of the leading space.
1239       ac_sep=" "
1240       ;;
1241     esac
1242   done
1243 done
1244 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1245 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1246
1247 # When interrupted or exit'd, cleanup temporary files, and complete
1248 # config.log.  We remove comments because anyway the quotes in there
1249 # would cause problems or look ugly.
1250 # WARNING: Be sure not to use single quotes in there, as some shells,
1251 # such as our DU 5.0 friend, will then `close' the trap.
1252 trap 'exit_status=$?
1253   # Save into config.log some information that might help in debugging.
1254   {
1255     echo
1256
1257     cat <<\_ASBOX
1258 ## ---------------- ##
1259 ## Cache variables. ##
1260 ## ---------------- ##
1261 _ASBOX
1262     echo
1263     # The following way of writing the cache mishandles newlines in values,
1264 {
1265   (set) 2>&1 |
1266     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1267     *ac_space=\ *)
1268       sed -n \
1269         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1270           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1271       ;;
1272     *)
1273       sed -n \
1274         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1275       ;;
1276     esac;
1277 }
1278     echo
1279
1280     cat <<\_ASBOX
1281 ## ----------------- ##
1282 ## Output variables. ##
1283 ## ----------------- ##
1284 _ASBOX
1285     echo
1286     for ac_var in $ac_subst_vars
1287     do
1288       eval ac_val=$`echo $ac_var`
1289       echo "$ac_var='"'"'$ac_val'"'"'"
1290     done | sort
1291     echo
1292
1293     if test -n "$ac_subst_files"; then
1294       cat <<\_ASBOX
1295 ## ------------- ##
1296 ## Output files. ##
1297 ## ------------- ##
1298 _ASBOX
1299       echo
1300       for ac_var in $ac_subst_files
1301       do
1302         eval ac_val=$`echo $ac_var`
1303         echo "$ac_var='"'"'$ac_val'"'"'"
1304       done | sort
1305       echo
1306     fi
1307
1308     if test -s confdefs.h; then
1309       cat <<\_ASBOX
1310 ## ----------- ##
1311 ## confdefs.h. ##
1312 ## ----------- ##
1313 _ASBOX
1314       echo
1315       sed "/^$/d" confdefs.h | sort
1316       echo
1317     fi
1318     test "$ac_signal" != 0 &&
1319       echo "$as_me: caught signal $ac_signal"
1320     echo "$as_me: exit $exit_status"
1321   } >&5
1322   rm -f core *.core &&
1323   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1324     exit $exit_status
1325      ' 0
1326 for ac_signal in 1 2 13 15; do
1327   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1328 done
1329 ac_signal=0
1330
1331 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1332 rm -rf conftest* confdefs.h
1333 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1334 echo >confdefs.h
1335
1336 # Predefined preprocessor variables.
1337
1338 cat >>confdefs.h <<_ACEOF
1339 #define PACKAGE_NAME "$PACKAGE_NAME"
1340 _ACEOF
1341
1342
1343 cat >>confdefs.h <<_ACEOF
1344 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1345 _ACEOF
1346
1347
1348 cat >>confdefs.h <<_ACEOF
1349 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1350 _ACEOF
1351
1352
1353 cat >>confdefs.h <<_ACEOF
1354 #define PACKAGE_STRING "$PACKAGE_STRING"
1355 _ACEOF
1356
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1360 _ACEOF
1361
1362
1363 # Let the site file select an alternate cache file if it wants to.
1364 # Prefer explicitly selected file to automatically selected ones.
1365 if test -z "$CONFIG_SITE"; then
1366   if test "x$prefix" != xNONE; then
1367     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1368   else
1369     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1370   fi
1371 fi
1372 for ac_site_file in $CONFIG_SITE; do
1373   if test -r "$ac_site_file"; then
1374     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1375 echo "$as_me: loading site script $ac_site_file" >&6;}
1376     sed 's/^/| /' "$ac_site_file" >&5
1377     . "$ac_site_file"
1378   fi
1379 done
1380
1381 if test -r "$cache_file"; then
1382   # Some versions of bash will fail to source /dev/null (special
1383   # files actually), so we avoid doing that.
1384   if test -f "$cache_file"; then
1385     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1386 echo "$as_me: loading cache $cache_file" >&6;}
1387     case $cache_file in
1388       [\\/]* | ?:[\\/]* ) . $cache_file;;
1389       *)                      . ./$cache_file;;
1390     esac
1391   fi
1392 else
1393   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1394 echo "$as_me: creating cache $cache_file" >&6;}
1395   >$cache_file
1396 fi
1397
1398 # Check that the precious variables saved in the cache have kept the same
1399 # value.
1400 ac_cache_corrupted=false
1401 for ac_var in `(set) 2>&1 |
1402                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1403   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1404   eval ac_new_set=\$ac_env_${ac_var}_set
1405   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1406   eval ac_new_val="\$ac_env_${ac_var}_value"
1407   case $ac_old_set,$ac_new_set in
1408     set,)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,set)
1413       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1414 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1415       ac_cache_corrupted=: ;;
1416     ,);;
1417     *)
1418       if test "x$ac_old_val" != "x$ac_new_val"; then
1419         # differences in whitespace do not lead to failure.
1420         ac_old_val_w=`echo x $ac_old_val`
1421         ac_new_val_w=`echo x $ac_new_val`
1422         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1423           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1424 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1425           ac_cache_corrupted=:
1426         else
1427           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1428 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1429           eval $ac_var=\$ac_old_val
1430         fi
1431         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1432 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1433         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1434 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1435       fi;;
1436   esac
1437   # Pass precious variables to config.status.
1438   if test "$ac_new_set" = set; then
1439     case $ac_new_val in
1440     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1441       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1442     *) ac_arg=$ac_var=$ac_new_val ;;
1443     esac
1444     case " $ac_configure_args " in
1445       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1446       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1447     esac
1448   fi
1449 done
1450 if $ac_cache_corrupted; then
1451   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1452 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1453   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1454 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1455   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1456 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1457    { (exit 1); exit 1; }; }
1458 fi
1459
1460 ac_ext=c
1461 ac_cpp='$CPP $CPPFLAGS'
1462 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1463 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1464 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489 progname=$0
1490 # if PWD already has a value, it is probably wrong.
1491 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1492
1493 # Export original configure arguments for use by sub-configures.
1494 # Quote arguments with shell meta charatcers.
1495 TOPLEVEL_CONFIGURE_ARGUMENTS=
1496 set -- "$progname" "$@"
1497 for ac_arg
1498 do
1499   case "$ac_arg" in
1500   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1501     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1502     # if the argument is of the form -foo=baz, quote the baz part only
1503     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1504   *) ;;
1505   esac
1506   # Add the quoted argument to the list.
1507   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1508 done
1509 if test "$silent" = yes; then
1510   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1511 fi
1512 # Remove the initial space we just introduced and, as these will be
1513 # expanded by make, quote '$'.
1514 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1515
1516
1517 # Find the build, host, and target systems.
1518 ac_aux_dir=
1519 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1520   if test -f $ac_dir/install-sh; then
1521     ac_aux_dir=$ac_dir
1522     ac_install_sh="$ac_aux_dir/install-sh -c"
1523     break
1524   elif test -f $ac_dir/install.sh; then
1525     ac_aux_dir=$ac_dir
1526     ac_install_sh="$ac_aux_dir/install.sh -c"
1527     break
1528   elif test -f $ac_dir/shtool; then
1529     ac_aux_dir=$ac_dir
1530     ac_install_sh="$ac_aux_dir/shtool install -c"
1531     break
1532   fi
1533 done
1534 if test -z "$ac_aux_dir"; then
1535   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1536 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1537    { (exit 1); exit 1; }; }
1538 fi
1539 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1540 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1541 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1542
1543 # Make sure we can run config.sub.
1544 $ac_config_sub sun4 >/dev/null 2>&1 ||
1545   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1546 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1547    { (exit 1); exit 1; }; }
1548
1549 echo "$as_me:$LINENO: checking build system type" >&5
1550 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1551 if test "${ac_cv_build+set}" = set; then
1552   echo $ECHO_N "(cached) $ECHO_C" >&6
1553 else
1554   ac_cv_build_alias=$build_alias
1555 test -z "$ac_cv_build_alias" &&
1556   ac_cv_build_alias=`$ac_config_guess`
1557 test -z "$ac_cv_build_alias" &&
1558   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1559 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1560    { (exit 1); exit 1; }; }
1561 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1562   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1563 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1564    { (exit 1); exit 1; }; }
1565
1566 fi
1567 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1568 echo "${ECHO_T}$ac_cv_build" >&6
1569 build=$ac_cv_build
1570 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1571 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1572 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1573
1574
1575  case ${build_alias} in
1576   "") build_noncanonical=${build} ;;
1577   *) build_noncanonical=${build_alias} ;;
1578 esac
1579
1580
1581
1582  case ${host_alias} in
1583   "") host_noncanonical=${build_noncanonical} ;;
1584   *) host_noncanonical=${host_alias} ;;
1585 esac
1586
1587
1588
1589  case ${target_alias} in
1590   "") target_noncanonical=${host_noncanonical} ;;
1591   *) target_noncanonical=${target_alias} ;;
1592 esac
1593
1594
1595
1596
1597 test "$host_noncanonical" = "$target_noncanonical" &&
1598   test "$program_prefix$program_suffix$program_transform_name" = \
1599     NONENONEs,x,x, &&
1600   program_transform_name=s,y,y,
1601
1602 echo "$as_me:$LINENO: checking host system type" >&5
1603 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1604 if test "${ac_cv_host+set}" = set; then
1605   echo $ECHO_N "(cached) $ECHO_C" >&6
1606 else
1607   ac_cv_host_alias=$host_alias
1608 test -z "$ac_cv_host_alias" &&
1609   ac_cv_host_alias=$ac_cv_build_alias
1610 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1611   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1612 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1613    { (exit 1); exit 1; }; }
1614
1615 fi
1616 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1617 echo "${ECHO_T}$ac_cv_host" >&6
1618 host=$ac_cv_host
1619 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1620 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1621 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1622
1623
1624 echo "$as_me:$LINENO: checking target system type" >&5
1625 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1626 if test "${ac_cv_target+set}" = set; then
1627   echo $ECHO_N "(cached) $ECHO_C" >&6
1628 else
1629   ac_cv_target_alias=$target_alias
1630 test "x$ac_cv_target_alias" = "x" &&
1631   ac_cv_target_alias=$ac_cv_host_alias
1632 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1633   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1634 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1635    { (exit 1); exit 1; }; }
1636
1637 fi
1638 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1639 echo "${ECHO_T}$ac_cv_target" >&6
1640 target=$ac_cv_target
1641 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1642 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1643 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1644
1645
1646 # The aliases save the names the user supplied, while $host etc.
1647 # will get canonicalized.
1648 test -n "$target_alias" &&
1649   test "$program_prefix$program_suffix$program_transform_name" = \
1650     NONENONEs,x,x, &&
1651   program_prefix=${target_alias}-
1652 test "$program_prefix" != NONE &&
1653   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1654 # Use a double $ so make ignores it.
1655 test "$program_suffix" != NONE &&
1656   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1657 # Double any \ or $.  echo might interpret backslashes.
1658 # By default was `s,x,x', remove it if useless.
1659 cat <<\_ACEOF >conftest.sed
1660 s/[\\$]/&&/g;s/;s,x,x,$//
1661 _ACEOF
1662 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1663 rm conftest.sed
1664
1665
1666
1667 # Get 'install' or 'install-sh' and its variants.
1668 # Find a good install program.  We prefer a C program (faster),
1669 # so one script is as good as another.  But avoid the broken or
1670 # incompatible versions:
1671 # SysV /etc/install, /usr/sbin/install
1672 # SunOS /usr/etc/install
1673 # IRIX /sbin/install
1674 # AIX /bin/install
1675 # AmigaOS /C/install, which installs bootblocks on floppy discs
1676 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1677 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1678 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1679 # OS/2's system install, which has a completely different semantic
1680 # ./install, which can be erroneously created by make from ./install.sh.
1681 # Reject install programs that cannot install multiple files.
1682 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1683 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1684 if test -z "$INSTALL"; then
1685 if test "${ac_cv_path_install+set}" = set; then
1686   echo $ECHO_N "(cached) $ECHO_C" >&6
1687 else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689 for as_dir in $PATH
1690 do
1691   IFS=$as_save_IFS
1692   test -z "$as_dir" && as_dir=.
1693   # Account for people who put trailing slashes in PATH elements.
1694 case $as_dir/ in
1695   ./ | .// | /cC/* | \
1696   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1697   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1698   /usr/ucb/* ) ;;
1699   *)
1700     # OSF1 and SCO ODT 3.0 have their own names for install.
1701     # Don't use installbsd from OSF since it installs stuff as root
1702     # by default.
1703     for ac_prog in ginstall scoinst install; do
1704       for ac_exec_ext in '' $ac_executable_extensions; do
1705         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1706           if test $ac_prog = install &&
1707             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1708             # AIX install.  It has an incompatible calling convention.
1709             :
1710           elif test $ac_prog = install &&
1711             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1712             # program-specific install script used by HP pwplus--don't use.
1713             :
1714           else
1715             rm -rf conftest.one conftest.two conftest.dir
1716             echo one > conftest.one
1717             echo two > conftest.two
1718             mkdir conftest.dir
1719             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1720               test -s conftest.one && test -s conftest.two &&
1721               test -s conftest.dir/conftest.one &&
1722               test -s conftest.dir/conftest.two
1723             then
1724               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1725               break 3
1726             fi
1727           fi
1728         fi
1729       done
1730     done
1731     ;;
1732 esac
1733 done
1734
1735 rm -rf conftest.one conftest.two conftest.dir
1736
1737 fi
1738   if test "${ac_cv_path_install+set}" = set; then
1739     INSTALL=$ac_cv_path_install
1740   else
1741     # As a last resort, use the slow shell script.  Don't cache a
1742     # value for INSTALL within a source directory, because that will
1743     # break other packages using the cache if that directory is
1744     # removed, or if the value is a relative name.
1745     INSTALL=$ac_install_sh
1746   fi
1747 fi
1748 echo "$as_me:$LINENO: result: $INSTALL" >&5
1749 echo "${ECHO_T}$INSTALL" >&6
1750
1751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1752 # It thinks the first close brace ends the variable substitution.
1753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1754
1755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1756
1757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1758
1759 echo "$as_me:$LINENO: checking whether ln works" >&5
1760 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1761 if test "${acx_cv_prog_LN+set}" = set; then
1762   echo $ECHO_N "(cached) $ECHO_C" >&6
1763 else
1764   rm -f conftestdata_t
1765 echo >conftestdata_f
1766 if ln conftestdata_f conftestdata_t 2>/dev/null
1767 then
1768   acx_cv_prog_LN=ln
1769 else
1770   acx_cv_prog_LN=no
1771 fi
1772 rm -f conftestdata_f conftestdata_t
1773
1774 fi
1775 if test $acx_cv_prog_LN = no; then
1776   LN="cp"
1777   echo "$as_me:$LINENO: result: no, using $LN" >&5
1778 echo "${ECHO_T}no, using $LN" >&6
1779 else
1780   LN="$acx_cv_prog_LN"
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783 fi
1784
1785 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1786 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1787 LN_S=$as_ln_s
1788 if test "$LN_S" = "ln -s"; then
1789   echo "$as_me:$LINENO: result: yes" >&5
1790 echo "${ECHO_T}yes" >&6
1791 else
1792   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1793 echo "${ECHO_T}no, using $LN_S" >&6
1794 fi
1795
1796
1797 ### we might need to use some other shell than /bin/sh for running subshells
1798 ### If we are on Windows, search for the shell.  This will permit people
1799 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1800 ### without also having to set CONFIG_SHELL.  This code will work when
1801 ### using bash, which sets OSTYPE.
1802 case "${OSTYPE}" in
1803 *win32*)
1804   if test x${CONFIG_SHELL} = x ; then
1805     if test ! -f /bin/sh ; then
1806       if test x${SHELL} != x && test -f ${SHELL} ; then
1807         CONFIG_SHELL=${SHELL}
1808         export CONFIG_SHELL
1809       else
1810         for prog in sh sh.exe bash bash.exe; do
1811           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1812           for dir in $PATH; do
1813             test -z "$dir" && dir=.
1814             if test -f $dir/$prog; then
1815               CONFIG_SHELL=$dir/$prog
1816               export CONFIG_SHELL
1817               break
1818             fi
1819           done
1820           IFS="$save_ifs"
1821           test -n "${CONFIG_SHELL}" && break
1822         done
1823       fi
1824     fi
1825   fi
1826   ;;
1827 esac
1828
1829 config_shell=${CONFIG_SHELL-/bin/sh}
1830
1831 moveifchange=${srcdir}/move-if-change
1832
1833 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1834
1835 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1836 # a relative path.
1837 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1838   INSTALL="${srcpwd}/install-sh -c"
1839 fi
1840
1841 # Set srcdir to "." if that's what it is.
1842 # This is important for multilib support.
1843 pwd=`${PWDCMD-pwd}`
1844 if test "${pwd}" = "${srcpwd}" ; then
1845   srcdir=.
1846 fi
1847
1848 topsrcdir=$srcpwd
1849
1850 extra_host_args=
1851
1852 ### To add a new directory to the tree, first choose whether it is a target
1853 ### or a host dependent tool.  Then put it into the appropriate list
1854 ### (library or tools, host or target), doing a dependency sort.
1855
1856 # Subdirs will be configured in the order listed in build_configdirs,
1857 # configdirs, or target_configdirs; see the serialization section below.
1858
1859 # Dependency sorting is only needed when *configuration* must be done in
1860 # a particular order.  In all cases a dependency should be specified in
1861 # the Makefile, whether or not it's implicitly specified here.
1862
1863 # Double entries in build_configdirs, configdirs, or target_configdirs may
1864 # cause circular dependencies and break everything horribly.
1865
1866 # these library is used by various programs built for the build
1867 # environment
1868 #
1869 build_libs="build-libiberty"
1870
1871 # these tools are built for the build environment
1872 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1873
1874 # these libraries are used by various programs built for the host environment
1875 #
1876 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1877
1878 # these tools are built for the host environment
1879 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1880 # know that we are building the simulator.
1881 # binutils, gas and ld appear in that order because it makes sense to run
1882 # "make check" in that particular order.
1883 # If --enable-gold is used, "gold" will replace "ld".
1884 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1885
1886 # libgcj represents the runtime libraries only used by gcj.
1887 libgcj="target-libffi \
1888         target-zlib \
1889         target-qthreads \
1890         target-libjava"
1891
1892 # these libraries are built for the target environment, and are built after
1893 # the host libraries and the host tools (which may be a cross compiler)
1894 #
1895 target_libraries="target-libgcc \
1896                 target-libiberty \
1897                 target-libgloss \
1898                 target-newlib \
1899                 target-libgomp \
1900                 target-libstdc++-v3 \
1901                 target-libmudflap \
1902                 target-libssp \
1903                 target-libgfortran \
1904                 target-boehm-gc \
1905                 ${libgcj} \
1906                 target-libobjc \
1907                 target-libada"
1908
1909 # these tools are built using the target libraries, and are intended to
1910 # run only in the target environment
1911 #
1912 # note: any program that *uses* libraries that are in the "target_libraries"
1913 # list belongs in this list.  those programs are also very likely
1914 # candidates for the "native_only" list which follows
1915 #
1916 target_tools="target-examples target-groff target-gperf target-rda"
1917
1918 ################################################################################
1919
1920 ## All tools belong in one of the four categories, and are assigned above
1921 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1922 ## is important because configure will choke if they ever get through.
1923 ## ${configdirs} is directories we build using the host tools.
1924 ## ${target_configdirs} is directories we build using the target tools.
1925 configdirs=`echo ${host_libs} ${host_tools}`
1926 target_configdirs=`echo ${target_libraries} ${target_tools}`
1927 build_configdirs=`echo ${build_libs} ${build_tools}`
1928
1929
1930
1931 ################################################################################
1932
1933 srcname="gnu development package"
1934
1935 # This gets set non-empty for some net releases of packages.
1936 appdirs=""
1937
1938 # Define is_cross_compiler to save on calls to 'test'.
1939 is_cross_compiler=
1940 if test x"${host}" = x"${target}" ; then
1941   is_cross_compiler=no
1942 else
1943   is_cross_compiler=yes
1944 fi
1945
1946 # Find the build and target subdir names.
1947
1948 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1949 # have matching libraries, they should use host libraries: Makefile.tpl
1950 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1951 # However, they still use the build modules, because the corresponding
1952 # host modules (e.g. bison) are only built for the host when bootstrap
1953 # finishes. So:
1954 # - build_subdir is where we find build modules, and never changes.
1955 # - build_libsubdir is where we find build libraries, and can be overridden.
1956
1957 # Prefix 'build-' so this never conflicts with target_subdir.
1958 build_subdir="build-${build_noncanonical}"
1959
1960 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1961 if test "${with_build_libsubdir+set}" = set; then
1962   withval="$with_build_libsubdir"
1963   build_libsubdir="$withval"
1964 else
1965   build_libsubdir="$build_subdir"
1966 fi;
1967 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1968 if ( test $srcdir = . && test -d gcc ) \
1969    || test -d $srcdir/../host-${host_noncanonical}; then
1970   host_subdir="host-${host_noncanonical}"
1971 else
1972   host_subdir=.
1973 fi
1974 # No prefix.
1975 target_subdir=${target_noncanonical}
1976
1977
1978 # Skipdirs are removed silently.
1979 skipdirs=
1980 # Noconfigdirs are removed loudly.
1981 noconfigdirs=""
1982
1983 use_gnu_ld=
1984 # Make sure we don't let GNU ld be added if we didn't want it.
1985 if test x$with_gnu_ld = xno ; then
1986   use_gnu_ld=no
1987   noconfigdirs="$noconfigdirs ld gold"
1988 fi
1989
1990 use_gnu_as=
1991 # Make sure we don't let GNU as be added if we didn't want it.
1992 if test x$with_gnu_as = xno ; then
1993   use_gnu_as=no
1994   noconfigdirs="$noconfigdirs gas"
1995 fi
1996
1997 # some tools are so dependent upon X11 that if we're not building with X,
1998 # it's not even worth trying to configure, much less build, that tool.
1999
2000 case ${with_x} in
2001   yes | "") ;; # the default value for this tree is that X11 is available
2002   no)
2003     skipdirs="${skipdirs} tk itcl libgui"
2004     # We won't be able to build gdbtk without X.
2005     enable_gdbtk=no
2006     ;;
2007   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2008 esac
2009
2010 # Some tools are only suitable for building in a "native" situation.
2011 # Remove these if host!=target.
2012 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"
2013
2014 # Similarly, some are only suitable for cross toolchains.
2015 # Remove these if host=target.
2016 cross_only="target-libgloss target-newlib target-opcodes"
2017
2018 case $is_cross_compiler in
2019   no) skipdirs="${skipdirs} ${cross_only}" ;;
2020   yes) skipdirs="${skipdirs} ${native_only}" ;;
2021 esac
2022
2023 # If both --with-headers and --with-libs are specified, default to
2024 # --without-newlib.
2025 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2026    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2027   if test x"${with_newlib}" = x ; then
2028     with_newlib=no
2029   fi
2030 fi
2031
2032 # Recognize --with-newlib/--without-newlib.
2033 case ${with_newlib} in
2034   no) skipdirs="${skipdirs} target-newlib" ;;
2035   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2036 esac
2037
2038 # Handle --enable-gold.
2039
2040 # Check whether --enable-gold or --disable-gold was given.
2041 if test "${enable_gold+set}" = set; then
2042   enableval="$enable_gold"
2043   ENABLE_GOLD=$enableval
2044 else
2045   ENABLE_GOLD=no
2046 fi;
2047 if test "${ENABLE_GOLD}" = "yes"; then
2048   # Check for ELF target.
2049   is_elf=no
2050   case "${target}" in
2051     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2052     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2053     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2054       case "${target}" in
2055         *-*-linux*aout* | *-*-linux*oldld*)
2056           ;;
2057         *)
2058           is_elf=yes
2059           ;;
2060       esac
2061   esac
2062
2063   if test "$is_elf" = "yes"; then
2064     # Check for target supported by gold.
2065     case "${target}" in
2066       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2067         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2068         ;;
2069     esac
2070   fi
2071 fi
2072
2073 # Configure extra directories which are host specific
2074
2075 case "${host}" in
2076   *-cygwin*)
2077     configdirs="$configdirs libtermcap" ;;
2078 esac
2079
2080 # A target can indicate whether a language isn't supported for some reason.
2081 # Only spaces may be used in this macro; not newlines or tabs.
2082 unsupported_languages=
2083
2084 # Remove more programs from consideration, based on the host or
2085 # target this usually means that a port of the program doesn't
2086 # exist yet.
2087
2088 case "${host}" in
2089   hppa*64*-*-*)
2090     noconfigdirs="$noconfigdirs byacc"
2091     ;;
2092   i[3456789]86-*-vsta)
2093     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2094     ;;
2095   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2096     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2097     ;;
2098   x86_64-*-mingw*)
2099     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2100     ;;
2101   i[3456789]86-*-mingw32*)
2102     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2103     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2104     ;;
2105   i[3456789]86-*-beos*)
2106     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2107     ;;
2108   *-*-cygwin*)
2109     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2110     ;;
2111   *-*-netbsd*)
2112     noconfigdirs="$noconfigdirs rcs"
2113     ;;
2114   ppc*-*-pe)
2115     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2116     ;;
2117   powerpc-*-beos*)
2118     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2119     ;;
2120 esac
2121
2122
2123 # Check whether --enable-libada or --disable-libada was given.
2124 if test "${enable_libada+set}" = set; then
2125   enableval="$enable_libada"
2126   ENABLE_LIBADA=$enableval
2127 else
2128   ENABLE_LIBADA=yes
2129 fi;
2130 if test "${ENABLE_LIBADA}" != "yes" ; then
2131   noconfigdirs="$noconfigdirs gnattools"
2132 fi
2133
2134 # Check whether --enable-libssp or --disable-libssp was given.
2135 if test "${enable_libssp+set}" = set; then
2136   enableval="$enable_libssp"
2137   ENABLE_LIBSSP=$enableval
2138 else
2139   ENABLE_LIBSSP=yes
2140 fi;
2141
2142 # Save it here so that, even in case of --enable-libgcj, if the Java
2143 # front-end isn't enabled, we still get libgcj disabled.
2144 libgcj_saved=$libgcj
2145 case $enable_libgcj in
2146 yes)
2147   # If we reset it here, it won't get added to noconfigdirs in the
2148   # target-specific build rules, so it will be forcibly enabled
2149   # (unless the Java language itself isn't enabled).
2150   libgcj=
2151   ;;
2152 no)
2153   # Make sure we get it printed in the list of not supported target libs.
2154   noconfigdirs="$noconfigdirs ${libgcj}"
2155   ;;
2156 esac
2157
2158
2159 # Disable libmudflap on some systems.
2160 if test x$enable_libmudflap = x ; then
2161     case "${target}" in
2162     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2163         # Enable libmudflap by default in GNU and friends.
2164         ;;
2165     *-*-freebsd*)
2166         # Enable libmudflap by default in FreeBSD.
2167         ;;
2168     *)
2169         # Disable it by default everywhere else.
2170         noconfigdirs="$noconfigdirs target-libmudflap"
2171         ;;
2172     esac
2173 fi
2174
2175 # Disable libgomp on non POSIX hosted systems.
2176 if test x$enable_libgomp = x ; then
2177     # Enable libgomp by default on hosted POSIX systems.
2178     case "${target}" in
2179     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2180         ;;
2181     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2182         ;;
2183     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2184         ;;
2185     *-*-darwin* | *-*-aix*)
2186         ;;
2187     *)
2188         noconfigdirs="$noconfigdirs target-libgomp"
2189         ;;
2190     esac
2191 fi
2192
2193 # Default libgloss CPU subdirectory.
2194 libgloss_dir="$target_cpu"
2195
2196 case "${target}" in
2197   *-*-chorusos)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2199     ;;
2200   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2201     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2202     noconfigdirs="$noconfigdirs sim target-rda"
2203     ;;
2204   *-*-darwin*)
2205     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2206     noconfigdirs="$noconfigdirs sim target-rda"
2207     noconfigdirs="$noconfigdirs ${libgcj}"
2208     ;;
2209   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2210     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2211     ;;
2212   *-*-freebsd*)
2213     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2214     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2215         && test -f /usr/local/include/gmp.h; then
2216       with_gmp=/usr/local
2217     fi
2218
2219     # Skip some stuff that's unsupported on some FreeBSD configurations.
2220     case "${target}" in
2221       i*86-*-*) ;;
2222       alpha*-*-*) ;;
2223       *)
2224         noconfigdirs="$noconfigdirs ${libgcj}"
2225         ;;
2226     esac
2227     ;;
2228   *-*-kaos*)
2229     # Remove unsupported stuff on all kaOS configurations.
2230     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2231     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2232     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2233     noconfigdirs="$noconfigdirs target-libgloss"
2234     ;;
2235   *-*-netbsd*)
2236     # Skip some stuff on all NetBSD configurations.
2237     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2238
2239     # Skip some stuff that's unsupported on some NetBSD configurations.
2240     case "${target}" in
2241       i*86-*-netbsdelf*) ;;
2242       arm*-*-netbsdelf*) ;;
2243       *)
2244         noconfigdirs="$noconfigdirs ${libgcj}"
2245         ;;
2246     esac
2247     ;;
2248   *-*-netware*)
2249     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2250     ;;
2251   *-*-rtems*)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254     # The tpf target doesn't support gdb yet.
2255   *-*-tpf*)
2256     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2257     ;;
2258   *-*-uclinux*)
2259     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2260     ;;
2261   *-*-vxworks*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2263     ;;
2264   alpha*-dec-osf*)
2265     # ld works, but does not support shared libraries.
2266     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2267     # gas doesn't generate exception information.
2268     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2269     ;;
2270   alpha*-*-*vms*)
2271     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2272     ;;
2273   alpha*-*-linux*)
2274     # newlib is not 64 bit ready
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2276     ;;
2277   alpha*-*-*)
2278     # newlib is not 64 bit ready
2279     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2280     ;;
2281   am33_2.0-*-linux*)
2282     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2283     ;;
2284   sh-*-linux*)
2285     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2286     ;;
2287   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2288     noconfigdirs="$noconfigdirs ${libgcj}"
2289     noconfigdirs="$noconfigdirs target-examples"
2290     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2291     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2292     noconfigdirs="$noconfigdirs expect dejagnu"
2293     # the C++ libraries don't build on top of CE's C libraries
2294     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2295     noconfigdirs="$noconfigdirs target-newlib"
2296     case "${host}" in
2297       *-*-cygwin*) ;; # keep gdb and readline
2298       *) noconfigdirs="$noconfigdirs gdb readline"
2299          ;;
2300     esac
2301     libgloss_dir=wince
2302     ;;
2303   arc-*-*)
2304     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2305     ;;
2306   arm-semi-aof )
2307     ;;
2308   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2309     noconfigdirs="$noconfigdirs ${libgcj}"
2310     libgloss_dir=arm
2311     ;;
2312   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2313     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2314     libgloss_dir=arm
2315     ;;
2316   arm*-*-linux-gnueabi)
2317     noconfigdirs="$noconfigdirs target-qthreads"
2318     case ${with_newlib} in
2319       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2320     esac
2321     libgloss_dir=arm
2322     ;;
2323   arm*-*-symbianelf*)
2324     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2325     libgloss_dir=arm
2326     ;;
2327   arm-*-pe*)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   thumb-*-coff)
2331     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2332     ;;
2333   thumb-*-elf)
2334     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2335     ;;
2336   thumb-*-pe)
2337     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2338     ;;
2339   arm-*-riscix*)
2340     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2341     ;;
2342   avr-*-*)
2343     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2344     ;;
2345   bfin-*-*)
2346     noconfigdirs="$noconfigdirs gdb"
2347     if test x${is_cross_compiler} != xno ; then
2348       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2349     fi
2350     ;;
2351   c4x-*-* | tic4x-*-*)
2352     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2353     ;;
2354   c54x*-*-* | tic54x-*-*)
2355     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2356     ;;
2357   cr16-*-*)
2358     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2359     ;;
2360   cris-*-* | crisv32-*-*)
2361     unsupported_languages="$unsupported_languages java"
2362     case "${target}" in
2363       *-*-aout)
2364         unsupported_languages="$unsupported_languages fortran"
2365         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2366       *-*-elf)
2367         noconfigdirs="$noconfigdirs target-boehm-gc";;
2368       *-*-linux*)
2369         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2370       *)
2371         unsupported_languages="$unsupported_languages fortran"
2372         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2373     esac
2374     libgloss_dir=cris
2375     ;;
2376   crx-*-*)
2377     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2378     ;;
2379   d10v-*-*)
2380     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2381     ;;
2382   d30v-*-*)
2383     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2384     ;;
2385   ep9312-*-elf | ep9312-*-coff)
2386     libgloss_dir=arm
2387     ;;
2388   fr30-*-elf*)
2389     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2390     ;;
2391   frv-*-*)
2392     noconfigdirs="$noconfigdirs ${libgcj}"
2393     ;;
2394   h8300*-*-*)
2395     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2396     ;;
2397   h8500-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2401     ;;
2402   hppa*64*-*-linux* | parisc*64*-*-linux*)
2403     # In this case, it's because the hppa64-linux target is for
2404     # the kernel only at this point and has no libc, and thus no
2405     # headers, crt*.o, etc., all of which are needed by these.
2406     noconfigdirs="$noconfigdirs target-zlib"
2407     ;;
2408   parisc*-*-linux* | hppa*-*-linux*)
2409     ;;
2410   hppa*-*-*elf* | \
2411   hppa*-*-lites* | \
2412   hppa*-*-openbsd* | \
2413   hppa*64*-*-*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   hppa*-hp-hpux11*)
2417     noconfigdirs="$noconfigdirs ld shellutils"
2418     ;;
2419   hppa*-*-pro*)
2420     libgloss_dir=pa
2421     ;;
2422   hppa*-*-*)
2423     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2424     # build on HP-UX 10.20.
2425     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2426     ;;
2427   i960-*-*)
2428     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2429     ;;
2430   ia64*-*-elf*)
2431     # No gdb support yet.
2432     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2433     ;;
2434   ia64*-**-hpux*)
2435     # No gdb or ld support yet.
2436     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2437     ;;
2438   i370-*-opened*)
2439     ;;
2440   i[3456789]86-*-coff | i[3456789]86-*-elf)
2441     noconfigdirs="$noconfigdirs ${libgcj}"
2442     libgloss_dir=i386
2443     ;;
2444   i[3456789]86-*-linux*)
2445     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2446     # not build java stuff by default.
2447     case "${target}" in
2448       *-*-*libc1*)
2449         noconfigdirs="$noconfigdirs ${libgcj}";;
2450     esac
2451
2452     # This section makes it possible to build newlib natively on linux.
2453     # If we are using a cross compiler then don't configure newlib.
2454     if test x${is_cross_compiler} != xno ; then
2455       noconfigdirs="$noconfigdirs target-newlib"
2456     fi
2457     noconfigdirs="$noconfigdirs target-libgloss"
2458     # If we are not using a cross compiler, do configure newlib.
2459     # Note however, that newlib will only be configured in this situation
2460     # if the --with-newlib option has been given, because otherwise
2461     # 'target-newlib' will appear in skipdirs.
2462     ;;
2463   i[3456789]86-*-mingw32*)
2464     target_configdirs="$target_configdirs target-winsup"
2465     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2466     ;;
2467   x86_64-*-mingw*)
2468     target_configdirs="$target_configdirs target-winsup"
2469     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2470     ;;
2471   *-*-cygwin*)
2472     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2473     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2474     # always build newlib if winsup directory is present.
2475     if test -d "$srcdir/winsup/cygwin"; then
2476       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2477     elif test -d "$srcdir/newlib"; then
2478       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2479     fi
2480     ;;
2481   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2482   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2483     ;;
2484   i[3456789]86-*-pe)
2485     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-sco3.2v5*)
2488     # The linker does not yet know about weak symbols in COFF,
2489     # and is not configured to handle mixed ELF and COFF.
2490     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2491     ;;
2492   i[3456789]86-*-sco*)
2493     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2494     ;;
2495   i[3456789]86-*-solaris2*)
2496     noconfigdirs="$noconfigdirs target-libgloss"
2497     ;;
2498   i[3456789]86-*-sysv4*)
2499     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2500     ;;
2501   i[3456789]86-*-beos*)
2502     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2503     ;;
2504   i[3456789]86-*-rdos*)
2505     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2506     ;;
2507   m32r-*-*)
2508     noconfigdirs="$noconfigdirs ${libgcj}"
2509     ;;
2510   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2511     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2512     libgloss_dir=m68hc11
2513     ;;
2514   m68k-*-elf*)
2515     noconfigdirs="$noconfigdirs ${libgcj}"
2516     ;;
2517   m68k-*-coff*)
2518     noconfigdirs="$noconfigdirs ${libgcj}"
2519     ;;
2520   m68*-*-* | fido-*-*)
2521     libgloss_dir=m68k
2522     ;;
2523   mcore-*-pe*)
2524   # The EPOC C++ environment does not support exceptions or rtti,
2525   # and so building libstdc++-v3 tends not to always work.
2526     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2527     ;;
2528   mmix-*-*)
2529     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2530     unsupported_languages="$unsupported_languages fortran java"
2531     ;;
2532   mn10200-*-*)
2533     noconfigdirs="$noconfigdirs ${libgcj}"
2534     ;;
2535   mn10300-*-*)
2536     noconfigdirs="$noconfigdirs ${libgcj}"
2537     ;;
2538   mt-*-*)
2539     noconfigdirs="$noconfigdirs sim"
2540     ;;
2541   powerpc-*-aix*)
2542     # copied from rs6000-*-* entry
2543     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2544     ;;
2545   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2546     target_configdirs="$target_configdirs target-winsup"
2547     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2548     # always build newlib.
2549     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2550     ;;
2551     # This is temporary until we can link against shared libraries
2552   powerpcle-*-solaris*)
2553     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2554     libgloss_dir=rs6000
2555     ;;
2556   powerpc-*-beos*)
2557     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2558     ;;
2559   powerpc-*-eabi)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=rs6000
2562     ;;
2563   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2564     libgloss_dir=rs6000
2565     ;;
2566   rs6000-*-lynxos*)
2567     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2568     ;;
2569   rs6000-*-aix*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2571     ;;
2572   rs6000-*-*)
2573     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2574     ;;
2575   m68k-apollo-*)
2576     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2577     ;;
2578   mips*-sde-elf*)
2579     skipdirs="$skipdirs target-libiberty"
2580     noconfigdirs="$noconfigdirs ${libgcj}"
2581     if test x$with_newlib = xyes; then
2582       noconfigdirs="$noconfigdirs gprof"
2583     fi
2584     libgloss_dir=mips
2585     ;;
2586   mips*-*-irix5*)
2587     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2588     ;;
2589   mips*-*-irix6*)
2590     # Linking libjava exceeds command-line length limits on at least
2591     # IRIX 6.2, but not on IRIX 6.5.
2592     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2593     # <oldham@codesourcery.com>
2594     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2595     ;;
2596   mips*-*-bsd*)
2597     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2598     ;;
2599   mips*-*-linux*)
2600     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2601     ;;
2602   mips*-*-*)
2603     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2604     libgloss_dir=mips
2605     ;;
2606   romp-*-*)
2607     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2608     ;;
2609   sh-*-* | sh64-*-*)
2610     case "${host}" in
2611       i[3456789]86-*-vsta) ;; # don't add gprof back in
2612       i[3456789]86-*-go32*) ;; # don't add gprof back in
2613       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2614       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2615     esac
2616     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2617     ;;
2618   sparclet-*-aout* | sparc86x-*-*)
2619     libgloss_dir=sparc
2620     ;;
2621   sparc-*-elf*)
2622     noconfigdirs="$noconfigdirs ${libgcj}"
2623     ;;
2624   sparc64-*-elf*)
2625     noconfigdirs="$noconfigdirs ${libgcj}"
2626     libgloss_dir=sparc
2627     ;;
2628   sparclite-*-*)
2629     noconfigdirs="$noconfigdirs ${libgcj}"
2630     libgloss_dir=sparc
2631     ;;
2632   sparc-*-sunos4*)
2633     noconfigdirs="$noconfigdirs ${libgcj}"
2634     if test x${is_cross_compiler} != xno ; then
2635            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2636     else
2637            use_gnu_ld=no
2638     fi
2639     ;;
2640   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2641     noconfigdirs="$noconfigdirs ${libgcj}"
2642     ;;
2643   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2644     ;;
2645   spu-*-*)
2646     ;;
2647   v810-*-*)
2648     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2649     ;;
2650   v850-*-*)
2651     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2652     ;;
2653   v850e-*-*)
2654     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2655     ;;
2656   v850ea-*-*)
2657     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2658     ;;
2659   vax-*-vms)
2660     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2661     ;;
2662   vax-*-*)
2663     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2664     ;;
2665   xtensa*-*-*)
2666     noconfigdirs="$noconfigdirs ${libgcj}"
2667     ;;
2668   ip2k-*-*)
2669     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2670     ;;
2671   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2672     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2673     ;;
2674   *-*-lynxos*)
2675     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2676     ;;
2677   *-*-*)
2678     noconfigdirs="$noconfigdirs ${libgcj}"
2679     ;;
2680 esac
2681
2682 # If we aren't building newlib, then don't build libgloss, since libgloss
2683 # depends upon some newlib header files.
2684 case "${noconfigdirs}" in
2685   *target-libgloss*) ;;
2686   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2687 esac
2688
2689 # Work in distributions that contain no compiler tools, like Autoconf.
2690 tentative_cc=""
2691 host_makefile_frag=/dev/null
2692 if test -d ${srcdir}/config ; then
2693 case "${host}" in
2694   m68k-hp-hpux*)
2695     # Avoid "too much defining" errors from HPUX compiler.
2696     tentative_cc="cc -Wp,-H256000"
2697     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2698     # If it's HP/UX ar, this should be harmless.
2699     RANLIB="ar ts"
2700     ;;
2701   m68k-apollo-sysv*)
2702     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2703     ;;
2704   m68k-apollo-bsd*)
2705     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2706     # chokes on bfd, the compiler won't let you assign integers to enums, and
2707     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2708     # the apollo compiler" (the preferred version of GCC could be called cc,
2709     # or whatever), but I'm not sure leaving CC as cc is any better...
2710     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2711     # Used to have BISON=yacc.
2712     tentative_cc=gcc
2713     ;;
2714   m88k-dg-dgux*)
2715     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2716     ;;
2717   m88k-harris-cxux*)
2718     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2719     tentative_cc="cc -Xa"
2720     host_makefile_frag="config/mh-cxux"
2721     ;;
2722   m88k-motorola-sysv*)
2723     ;;
2724   mips*-dec-ultrix*)
2725     tentative_cc="cc -Wf,-XNg1000"
2726     host_makefile_frag="config/mh-decstation"
2727     ;;
2728   mips*-nec-sysv4*)
2729     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2730     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2731     host_makefile_frag="config/mh-necv4"
2732     ;;
2733   mips*-sgi-irix4*)
2734     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2735     # environment.  Also bump switch table size so that cp-parse will
2736     # compile.  Bump string length limit so linker builds.
2737     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2738     ;;
2739   mips*-*-sysv4*)
2740     host_makefile_frag="config/mh-sysv4"
2741     ;;
2742   mips*-*-sysv*)
2743     # This is for a MIPS running RISC/os 4.52C.
2744
2745     # This is needed for GDB, but needs to be in the top-level make because
2746     # if a library is compiled with the bsd headers and gets linked with the
2747     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2748     # a different size).
2749     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2750     # known except to select the sysv environment.  Could we use /proc instead?
2751     # These "sysv environments" and "bsd environments" often end up being a pain.
2752     #
2753     # This is not part of CFLAGS because perhaps not all C compilers have this
2754     # option.
2755     tentative_cc="cc -systype sysv"
2756     ;;
2757   i370-ibm-opened*)
2758     tentative_cc="c89"
2759     ;;
2760   i[3456789]86-*-sysv5*)
2761     host_makefile_frag="config/mh-sysv5"
2762     ;;
2763   i[3456789]86-*-dgux*)
2764     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2765     host_makefile_frag="config/mh-dgux386"
2766     ;;
2767   i[3456789]86-ncr-sysv4.3*)
2768     # The MetaWare compiler will generate a copyright message unless you
2769     # turn it off by adding the -Hnocopyr flag.
2770     tentative_cc="cc -Hnocopyr"
2771     ;;
2772   i[3456789]86-ncr-sysv4*)
2773     # for an NCR 3000 (i486/SVR4) system.
2774     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2775     # This compiler not only emits obnoxious copyright messages every time
2776     # you run it, but it chokes and dies on a whole bunch of GNU source
2777     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2778     tentative_cc="/usr/ccs/ATT/cc"
2779     host_makefile_frag="config/mh-ncr3000"
2780     ;;
2781   i[3456789]86-*-sco3.2v5*)
2782     ;;
2783   i[3456789]86-*-sco*)
2784     # The native C compiler botches some simple uses of const.  Unfortunately,
2785     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2786     tentative_cc="cc -Dconst="
2787     host_makefile_frag="config/mh-sco"
2788     ;;
2789   i[3456789]86-*-udk*)
2790     host_makefile_frag="config/mh-sysv5"
2791     ;;
2792   i[3456789]86-*-solaris2*)
2793     host_makefile_frag="config/mh-sysv4"
2794     ;;
2795   i[3456789]86-*-msdosdjgpp*)
2796     host_makefile_frag="config/mh-djgpp"
2797     ;;
2798   *-cygwin*)
2799
2800 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2801 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2802 echo a >cygwin-cat-check
2803 if test `cat cygwin-cat-check` == a ; then
2804   rm cygwin-cat-check
2805   echo "$as_me:$LINENO: result: yes" >&5
2806 echo "${ECHO_T}yes" >&6
2807 else
2808   rm cygwin-cat-check
2809   echo "$as_me:$LINENO: result: no" >&5
2810 echo "${ECHO_T}no" >&6
2811   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2812   Please either mount the build directory in binary mode or run the following
2813   commands before running any configure script:
2814 set -o igncr
2815 export SHELLOPTS
2816   " >&5
2817 echo "$as_me: error: The cat command does not ignore carriage return characters.
2818   Please either mount the build directory in binary mode or run the following
2819   commands before running any configure script:
2820 set -o igncr
2821 export SHELLOPTS
2822   " >&2;}
2823    { (exit 1); exit 1; }; }
2824 fi
2825
2826     host_makefile_frag="config/mh-cygwin"
2827     ;;
2828   *-mingw*)
2829     host_makefile_frag="config/mh-mingw"
2830     ;;
2831   *-interix*)
2832     host_makefile_frag="config/mh-interix"
2833     ;;
2834   vax-*-ultrix2*)
2835     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2836     tentative_cc=gcc
2837     ;;
2838   *-*-solaris2*)
2839     host_makefile_frag="config/mh-solaris"
2840     ;;
2841   m68k-sun-sunos*)
2842     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2843     # without overflowing the jump tables (-J says to use a 32 bit table)
2844     tentative_cc="cc -J"
2845     ;;
2846   hppa*-hp-hpux10*)
2847     tentative_cc="cc -Wp,-H256000"
2848     host_makefile_frag="config/mh-pa-hpux10"
2849     ;;
2850   hppa*-hp-hpux* | hppa*-*-hiux*)
2851     tentative_cc="cc -Wp,-H256000"
2852     host_makefile_frag="config/mh-pa"
2853     ;;
2854   hppa*-*)
2855     host_makefile_frag="config/mh-pa"
2856     ;;
2857   *-hp-hpux* | *-*-hiux*)
2858     tentative_cc="cc -Wp,-H256000"
2859     ;;
2860   rs6000-*-lynxos*)
2861     # /bin/cc is less than useful for our purposes.  Always use GCC
2862     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2863     host_makefile_frag="config/mh-lynxrs6k"
2864     ;;
2865   powerpc-*-darwin*)
2866     host_makefile_frag="config/mh-ppc-darwin"
2867     ;;
2868   powerpc-*-aix*)
2869     host_makefile_frag="config/mh-ppc-aix"
2870     ;;
2871   rs6000-*-aix*)
2872     host_makefile_frag="config/mh-ppc-aix"
2873     ;;
2874   *-*-lynxos*)
2875     # /bin/cc is less than useful for our purposes.  Always use GCC
2876     tentative_cc="/bin/gcc"
2877     ;;
2878   *-*-sysv4*)
2879     host_makefile_frag="config/mh-sysv4"
2880     ;;
2881   # This is placed last to prevent interfering with the cases above.
2882   i[3456789]86-*-*)
2883     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2884     host_makefile_frag="config/mh-x86omitfp"
2885     ;;
2886 esac
2887 fi
2888
2889 # If we aren't going to be using gcc, see if we can extract a definition
2890 # of CC from the fragment.
2891 # Actually, use the 'pre-extracted' version above.
2892 if test -z "${CC}" && test "${build}" = "${host}" ; then
2893   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2894   found=
2895   for dir in $PATH; do
2896     test -z "$dir" && dir=.
2897     if test -f $dir/gcc; then
2898       found=yes
2899       break
2900     fi
2901   done
2902   IFS="$save_ifs"
2903   if test -z "${found}" && test -n "${tentative_cc}" ; then
2904     CC=$tentative_cc
2905   fi
2906 fi
2907
2908 if test "${build}" != "${host}" ; then
2909   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2910   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2911   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2912   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2913   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2914   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2915   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2916   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2917   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2918   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2919   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2920   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2921 else
2922   AR_FOR_BUILD="\$(AR)"
2923   AS_FOR_BUILD="\$(AS)"
2924   CC_FOR_BUILD="\$(CC)"
2925   CXX_FOR_BUILD="\$(CXX)"
2926   GCJ_FOR_BUILD="\$(GCJ)"
2927   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2928   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2929   LD_FOR_BUILD="\$(LD)"
2930   NM_FOR_BUILD="\$(NM)"
2931   RANLIB_FOR_BUILD="\$(RANLIB)"
2932   WINDRES_FOR_BUILD="\$(WINDRES)"
2933   WINDMC_FOR_BUILD="\$(WINDMC)"
2934 fi
2935
2936 ac_ext=c
2937 ac_cpp='$CPP $CPPFLAGS'
2938 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2939 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2940 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2941 if test -n "$ac_tool_prefix"; then
2942   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2943 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2944 echo "$as_me:$LINENO: checking for $ac_word" >&5
2945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2946 if test "${ac_cv_prog_CC+set}" = set; then
2947   echo $ECHO_N "(cached) $ECHO_C" >&6
2948 else
2949   if test -n "$CC"; then
2950   ac_cv_prog_CC="$CC" # Let the user override the test.
2951 else
2952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2953 for as_dir in $PATH
2954 do
2955   IFS=$as_save_IFS
2956   test -z "$as_dir" && as_dir=.
2957   for ac_exec_ext in '' $ac_executable_extensions; do
2958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2959     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2961     break 2
2962   fi
2963 done
2964 done
2965
2966 fi
2967 fi
2968 CC=$ac_cv_prog_CC
2969 if test -n "$CC"; then
2970   echo "$as_me:$LINENO: result: $CC" >&5
2971 echo "${ECHO_T}$CC" >&6
2972 else
2973   echo "$as_me:$LINENO: result: no" >&5
2974 echo "${ECHO_T}no" >&6
2975 fi
2976
2977 fi
2978 if test -z "$ac_cv_prog_CC"; then
2979   ac_ct_CC=$CC
2980   # Extract the first word of "gcc", so it can be a program name with args.
2981 set dummy gcc; ac_word=$2
2982 echo "$as_me:$LINENO: checking for $ac_word" >&5
2983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2984 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2985   echo $ECHO_N "(cached) $ECHO_C" >&6
2986 else
2987   if test -n "$ac_ct_CC"; then
2988   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2989 else
2990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2991 for as_dir in $PATH
2992 do
2993   IFS=$as_save_IFS
2994   test -z "$as_dir" && as_dir=.
2995   for ac_exec_ext in '' $ac_executable_extensions; do
2996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2997     ac_cv_prog_ac_ct_CC="gcc"
2998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2999     break 2
3000   fi
3001 done
3002 done
3003
3004 fi
3005 fi
3006 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3007 if test -n "$ac_ct_CC"; then
3008   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3009 echo "${ECHO_T}$ac_ct_CC" >&6
3010 else
3011   echo "$as_me:$LINENO: result: no" >&5
3012 echo "${ECHO_T}no" >&6
3013 fi
3014
3015   CC=$ac_ct_CC
3016 else
3017   CC="$ac_cv_prog_CC"
3018 fi
3019
3020 if test -z "$CC"; then
3021   if test -n "$ac_tool_prefix"; then
3022   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3023 set dummy ${ac_tool_prefix}cc; ac_word=$2
3024 echo "$as_me:$LINENO: checking for $ac_word" >&5
3025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3026 if test "${ac_cv_prog_CC+set}" = set; then
3027   echo $ECHO_N "(cached) $ECHO_C" >&6
3028 else
3029   if test -n "$CC"; then
3030   ac_cv_prog_CC="$CC" # Let the user override the test.
3031 else
3032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3033 for as_dir in $PATH
3034 do
3035   IFS=$as_save_IFS
3036   test -z "$as_dir" && as_dir=.
3037   for ac_exec_ext in '' $ac_executable_extensions; do
3038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3039     ac_cv_prog_CC="${ac_tool_prefix}cc"
3040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3041     break 2
3042   fi
3043 done
3044 done
3045
3046 fi
3047 fi
3048 CC=$ac_cv_prog_CC
3049 if test -n "$CC"; then
3050   echo "$as_me:$LINENO: result: $CC" >&5
3051 echo "${ECHO_T}$CC" >&6
3052 else
3053   echo "$as_me:$LINENO: result: no" >&5
3054 echo "${ECHO_T}no" >&6
3055 fi
3056
3057 fi
3058 if test -z "$ac_cv_prog_CC"; then
3059   ac_ct_CC=$CC
3060   # Extract the first word of "cc", so it can be a program name with args.
3061 set dummy cc; ac_word=$2
3062 echo "$as_me:$LINENO: checking for $ac_word" >&5
3063 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3064 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3065   echo $ECHO_N "(cached) $ECHO_C" >&6
3066 else
3067   if test -n "$ac_ct_CC"; then
3068   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3069 else
3070 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3071 for as_dir in $PATH
3072 do
3073   IFS=$as_save_IFS
3074   test -z "$as_dir" && as_dir=.
3075   for ac_exec_ext in '' $ac_executable_extensions; do
3076   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3077     ac_cv_prog_ac_ct_CC="cc"
3078     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3079     break 2
3080   fi
3081 done
3082 done
3083
3084 fi
3085 fi
3086 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3087 if test -n "$ac_ct_CC"; then
3088   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3089 echo "${ECHO_T}$ac_ct_CC" >&6
3090 else
3091   echo "$as_me:$LINENO: result: no" >&5
3092 echo "${ECHO_T}no" >&6
3093 fi
3094
3095   CC=$ac_ct_CC
3096 else
3097   CC="$ac_cv_prog_CC"
3098 fi
3099
3100 fi
3101 if test -z "$CC"; then
3102   # Extract the first word of "cc", so it can be a program name with args.
3103 set dummy cc; ac_word=$2
3104 echo "$as_me:$LINENO: checking for $ac_word" >&5
3105 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3106 if test "${ac_cv_prog_CC+set}" = set; then
3107   echo $ECHO_N "(cached) $ECHO_C" >&6
3108 else
3109   if test -n "$CC"; then
3110   ac_cv_prog_CC="$CC" # Let the user override the test.
3111 else
3112   ac_prog_rejected=no
3113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3114 for as_dir in $PATH
3115 do
3116   IFS=$as_save_IFS
3117   test -z "$as_dir" && as_dir=.
3118   for ac_exec_ext in '' $ac_executable_extensions; do
3119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3120     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3121        ac_prog_rejected=yes
3122        continue
3123      fi
3124     ac_cv_prog_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 if test $ac_prog_rejected = yes; then
3132   # We found a bogon in the path, so make sure we never use it.
3133   set dummy $ac_cv_prog_CC
3134   shift
3135   if test $# != 0; then
3136     # We chose a different compiler from the bogus one.
3137     # However, it has the same basename, so the bogon will be chosen
3138     # first if we set CC to just the basename; use the full file name.
3139     shift
3140     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3141   fi
3142 fi
3143 fi
3144 fi
3145 CC=$ac_cv_prog_CC
3146 if test -n "$CC"; then
3147   echo "$as_me:$LINENO: result: $CC" >&5
3148 echo "${ECHO_T}$CC" >&6
3149 else
3150   echo "$as_me:$LINENO: result: no" >&5
3151 echo "${ECHO_T}no" >&6
3152 fi
3153
3154 fi
3155 if test -z "$CC"; then
3156   if test -n "$ac_tool_prefix"; then
3157   for ac_prog in cl
3158   do
3159     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3160 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3161 echo "$as_me:$LINENO: checking for $ac_word" >&5
3162 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3163 if test "${ac_cv_prog_CC+set}" = set; then
3164   echo $ECHO_N "(cached) $ECHO_C" >&6
3165 else
3166   if test -n "$CC"; then
3167   ac_cv_prog_CC="$CC" # Let the user override the test.
3168 else
3169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3170 for as_dir in $PATH
3171 do
3172   IFS=$as_save_IFS
3173   test -z "$as_dir" && as_dir=.
3174   for ac_exec_ext in '' $ac_executable_extensions; do
3175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3176     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3178     break 2
3179   fi
3180 done
3181 done
3182
3183 fi
3184 fi
3185 CC=$ac_cv_prog_CC
3186 if test -n "$CC"; then
3187   echo "$as_me:$LINENO: result: $CC" >&5
3188 echo "${ECHO_T}$CC" >&6
3189 else
3190   echo "$as_me:$LINENO: result: no" >&5
3191 echo "${ECHO_T}no" >&6
3192 fi
3193
3194     test -n "$CC" && break
3195   done
3196 fi
3197 if test -z "$CC"; then
3198   ac_ct_CC=$CC
3199   for ac_prog in cl
3200 do
3201   # Extract the first word of "$ac_prog", so it can be a program name with args.
3202 set dummy $ac_prog; ac_word=$2
3203 echo "$as_me:$LINENO: checking for $ac_word" >&5
3204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3205 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3206   echo $ECHO_N "(cached) $ECHO_C" >&6
3207 else
3208   if test -n "$ac_ct_CC"; then
3209   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3210 else
3211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3212 for as_dir in $PATH
3213 do
3214   IFS=$as_save_IFS
3215   test -z "$as_dir" && as_dir=.
3216   for ac_exec_ext in '' $ac_executable_extensions; do
3217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3218     ac_cv_prog_ac_ct_CC="$ac_prog"
3219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3220     break 2
3221   fi
3222 done
3223 done
3224
3225 fi
3226 fi
3227 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3228 if test -n "$ac_ct_CC"; then
3229   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3230 echo "${ECHO_T}$ac_ct_CC" >&6
3231 else
3232   echo "$as_me:$LINENO: result: no" >&5
3233 echo "${ECHO_T}no" >&6
3234 fi
3235
3236   test -n "$ac_ct_CC" && break
3237 done
3238
3239   CC=$ac_ct_CC
3240 fi
3241
3242 fi
3243
3244
3245 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3246 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3247 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3248 See \`config.log' for more details." >&5
3249 echo "$as_me: error: no acceptable C compiler found in \$PATH
3250 See \`config.log' for more details." >&2;}
3251    { (exit 1); exit 1; }; }; }
3252
3253 # Provide some information about the compiler.
3254 echo "$as_me:$LINENO:" \
3255      "checking for C compiler version" >&5
3256 ac_compiler=`set X $ac_compile; echo $2`
3257 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3258   (eval $ac_compiler --version </dev/null >&5) 2>&5
3259   ac_status=$?
3260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3261   (exit $ac_status); }
3262 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3263   (eval $ac_compiler -v </dev/null >&5) 2>&5
3264   ac_status=$?
3265   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3266   (exit $ac_status); }
3267 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3268   (eval $ac_compiler -V </dev/null >&5) 2>&5
3269   ac_status=$?
3270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3271   (exit $ac_status); }
3272
3273 cat >conftest.$ac_ext <<_ACEOF
3274 /* confdefs.h.  */
3275 _ACEOF
3276 cat confdefs.h >>conftest.$ac_ext
3277 cat >>conftest.$ac_ext <<_ACEOF
3278 /* end confdefs.h.  */
3279
3280 int
3281 main ()
3282 {
3283
3284   ;
3285   return 0;
3286 }
3287 _ACEOF
3288 ac_clean_files_save=$ac_clean_files
3289 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3290 # Try to create an executable without -o first, disregard a.out.
3291 # It will help us diagnose broken compilers, and finding out an intuition
3292 # of exeext.
3293 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3294 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3295 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3296 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3297   (eval $ac_link_default) 2>&5
3298   ac_status=$?
3299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3300   (exit $ac_status); }; then
3301   # Find the output, starting from the most likely.  This scheme is
3302 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3303 # resort.
3304
3305 # Be careful to initialize this variable, since it used to be cached.
3306 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3307 ac_cv_exeext=
3308 # b.out is created by i960 compilers.
3309 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3310 do
3311   test -f "$ac_file" || continue
3312   case $ac_file in
3313     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3314         ;;
3315     conftest.$ac_ext )
3316         # This is the source file.
3317         ;;
3318     [ab].out )
3319         # We found the default executable, but exeext='' is most
3320         # certainly right.
3321         break;;
3322     *.* )
3323         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3324         # FIXME: I believe we export ac_cv_exeext for Libtool,
3325         # but it would be cool to find out if it's true.  Does anybody
3326         # maintain Libtool? --akim.
3327         export ac_cv_exeext
3328         break;;
3329     * )
3330         break;;
3331   esac
3332 done
3333 else
3334   echo "$as_me: failed program was:" >&5
3335 sed 's/^/| /' conftest.$ac_ext >&5
3336
3337 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3338 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3339 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3340 See \`config.log' for more details." >&5
3341 echo "$as_me: error: C compiler cannot create executables
3342 See \`config.log' for more details." >&2;}
3343    { (exit 77); exit 77; }; }; }
3344 fi
3345
3346 ac_exeext=$ac_cv_exeext
3347 echo "$as_me:$LINENO: result: $ac_file" >&5
3348 echo "${ECHO_T}$ac_file" >&6
3349
3350 # Check the compiler produces executables we can run.  If not, either
3351 # the compiler is broken, or we cross compile.
3352 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3353 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3354 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3355 # If not cross compiling, check that we can run a simple program.
3356 if test "$cross_compiling" != yes; then
3357   if { ac_try='./$ac_file'
3358   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3359   (eval $ac_try) 2>&5
3360   ac_status=$?
3361   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3362   (exit $ac_status); }; }; then
3363     cross_compiling=no
3364   else
3365     if test "$cross_compiling" = maybe; then
3366         cross_compiling=yes
3367     else
3368         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3369 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3370 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3371 If you meant to cross compile, use \`--host'.
3372 See \`config.log' for more details." >&5
3373 echo "$as_me: error: cannot run C compiled programs.
3374 If you meant to cross compile, use \`--host'.
3375 See \`config.log' for more details." >&2;}
3376    { (exit 1); exit 1; }; }; }
3377     fi
3378   fi
3379 fi
3380 echo "$as_me:$LINENO: result: yes" >&5
3381 echo "${ECHO_T}yes" >&6
3382
3383 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3384 ac_clean_files=$ac_clean_files_save
3385 # Check the compiler produces executables we can run.  If not, either
3386 # the compiler is broken, or we cross compile.
3387 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3388 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3389 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3390 echo "${ECHO_T}$cross_compiling" >&6
3391
3392 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3393 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3394 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3395   (eval $ac_link) 2>&5
3396   ac_status=$?
3397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3398   (exit $ac_status); }; then
3399   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3400 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3401 # work properly (i.e., refer to `conftest.exe'), while it won't with
3402 # `rm'.
3403 for ac_file in conftest.exe conftest conftest.*; do
3404   test -f "$ac_file" || continue
3405   case $ac_file in
3406     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3407     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3408           export ac_cv_exeext
3409           break;;
3410     * ) break;;
3411   esac
3412 done
3413 else
3414   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3415 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3416 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3417 See \`config.log' for more details." >&5
3418 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3419 See \`config.log' for more details." >&2;}
3420    { (exit 1); exit 1; }; }; }
3421 fi
3422
3423 rm -f conftest$ac_cv_exeext
3424 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3425 echo "${ECHO_T}$ac_cv_exeext" >&6
3426
3427 rm -f conftest.$ac_ext
3428 EXEEXT=$ac_cv_exeext
3429 ac_exeext=$EXEEXT
3430 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3431 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3432 if test "${ac_cv_objext+set}" = set; then
3433   echo $ECHO_N "(cached) $ECHO_C" >&6
3434 else
3435   cat >conftest.$ac_ext <<_ACEOF
3436 /* confdefs.h.  */
3437 _ACEOF
3438 cat confdefs.h >>conftest.$ac_ext
3439 cat >>conftest.$ac_ext <<_ACEOF
3440 /* end confdefs.h.  */
3441
3442 int
3443 main ()
3444 {
3445
3446   ;
3447   return 0;
3448 }
3449 _ACEOF
3450 rm -f conftest.o conftest.obj
3451 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3452   (eval $ac_compile) 2>&5
3453   ac_status=$?
3454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3455   (exit $ac_status); }; then
3456   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3457   case $ac_file in
3458     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3459     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3460        break;;
3461   esac
3462 done
3463 else
3464   echo "$as_me: failed program was:" >&5
3465 sed 's/^/| /' conftest.$ac_ext >&5
3466
3467 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3468 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3469 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3470 See \`config.log' for more details." >&5
3471 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3472 See \`config.log' for more details." >&2;}
3473    { (exit 1); exit 1; }; }; }
3474 fi
3475
3476 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3477 fi
3478 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3479 echo "${ECHO_T}$ac_cv_objext" >&6
3480 OBJEXT=$ac_cv_objext
3481 ac_objext=$OBJEXT
3482 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3483 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3484 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3485   echo $ECHO_N "(cached) $ECHO_C" >&6
3486 else
3487   cat >conftest.$ac_ext <<_ACEOF
3488 /* confdefs.h.  */
3489 _ACEOF
3490 cat confdefs.h >>conftest.$ac_ext
3491 cat >>conftest.$ac_ext <<_ACEOF
3492 /* end confdefs.h.  */
3493
3494 int
3495 main ()
3496 {
3497 #ifndef __GNUC__
3498        choke me
3499 #endif
3500
3501   ;
3502   return 0;
3503 }
3504 _ACEOF
3505 rm -f conftest.$ac_objext
3506 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3507   (eval $ac_compile) 2>conftest.er1
3508   ac_status=$?
3509   grep -v '^ *+' conftest.er1 >conftest.err
3510   rm -f conftest.er1
3511   cat conftest.err >&5
3512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513   (exit $ac_status); } &&
3514          { ac_try='test -z "$ac_c_werror_flag"
3515                          || test ! -s conftest.err'
3516   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3517   (eval $ac_try) 2>&5
3518   ac_status=$?
3519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3520   (exit $ac_status); }; } &&
3521          { ac_try='test -s conftest.$ac_objext'
3522   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3523   (eval $ac_try) 2>&5
3524   ac_status=$?
3525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3526   (exit $ac_status); }; }; then
3527   ac_compiler_gnu=yes
3528 else
3529   echo "$as_me: failed program was:" >&5
3530 sed 's/^/| /' conftest.$ac_ext >&5
3531
3532 ac_compiler_gnu=no
3533 fi
3534 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3535 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3536
3537 fi
3538 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3539 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3540 GCC=`test $ac_compiler_gnu = yes && echo yes`
3541 ac_test_CFLAGS=${CFLAGS+set}
3542 ac_save_CFLAGS=$CFLAGS
3543 CFLAGS="-g"
3544 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3545 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3546 if test "${ac_cv_prog_cc_g+set}" = set; then
3547   echo $ECHO_N "(cached) $ECHO_C" >&6
3548 else
3549   cat >conftest.$ac_ext <<_ACEOF
3550 /* confdefs.h.  */
3551 _ACEOF
3552 cat confdefs.h >>conftest.$ac_ext
3553 cat >>conftest.$ac_ext <<_ACEOF
3554 /* end confdefs.h.  */
3555
3556 int
3557 main ()
3558 {
3559
3560   ;
3561   return 0;
3562 }
3563 _ACEOF
3564 rm -f conftest.$ac_objext
3565 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3566   (eval $ac_compile) 2>conftest.er1
3567   ac_status=$?
3568   grep -v '^ *+' conftest.er1 >conftest.err
3569   rm -f conftest.er1
3570   cat conftest.err >&5
3571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3572   (exit $ac_status); } &&
3573          { ac_try='test -z "$ac_c_werror_flag"
3574                          || test ! -s conftest.err'
3575   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3576   (eval $ac_try) 2>&5
3577   ac_status=$?
3578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3579   (exit $ac_status); }; } &&
3580          { ac_try='test -s conftest.$ac_objext'
3581   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3582   (eval $ac_try) 2>&5
3583   ac_status=$?
3584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3585   (exit $ac_status); }; }; then
3586   ac_cv_prog_cc_g=yes
3587 else
3588   echo "$as_me: failed program was:" >&5
3589 sed 's/^/| /' conftest.$ac_ext >&5
3590
3591 ac_cv_prog_cc_g=no
3592 fi
3593 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3594 fi
3595 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3596 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3597 if test "$ac_test_CFLAGS" = set; then
3598   CFLAGS=$ac_save_CFLAGS
3599 elif test $ac_cv_prog_cc_g = yes; then
3600   if test "$GCC" = yes; then
3601     CFLAGS="-g -O2"
3602   else
3603     CFLAGS="-g"
3604   fi
3605 else
3606   if test "$GCC" = yes; then
3607     CFLAGS="-O2"
3608   else
3609     CFLAGS=
3610   fi
3611 fi
3612 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3613 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3614 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3615   echo $ECHO_N "(cached) $ECHO_C" >&6
3616 else
3617   ac_cv_prog_cc_stdc=no
3618 ac_save_CC=$CC
3619 cat >conftest.$ac_ext <<_ACEOF
3620 /* confdefs.h.  */
3621 _ACEOF
3622 cat confdefs.h >>conftest.$ac_ext
3623 cat >>conftest.$ac_ext <<_ACEOF
3624 /* end confdefs.h.  */
3625 #include <stdarg.h>
3626 #include <stdio.h>
3627 #include <sys/types.h>
3628 #include <sys/stat.h>
3629 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3630 struct buf { int x; };
3631 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3632 static char *e (p, i)
3633      char **p;
3634      int i;
3635 {
3636   return p[i];
3637 }
3638 static char *f (char * (*g) (char **, int), char **p, ...)
3639 {
3640   char *s;
3641   va_list v;
3642   va_start (v,p);
3643   s = g (p, va_arg (v,int));
3644   va_end (v);
3645   return s;
3646 }
3647
3648 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3649    function prototypes and stuff, but not '\xHH' hex character constants.
3650    These don't provoke an error unfortunately, instead are silently treated
3651    as 'x'.  The following induces an error, until -std1 is added to get
3652    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3653    array size at least.  It's necessary to write '\x00'==0 to get something
3654    that's true only with -std1.  */
3655 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3656
3657 int test (int i, double x);
3658 struct s1 {int (*f) (int a);};
3659 struct s2 {int (*f) (double a);};
3660 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3661 int argc;
3662 char **argv;
3663 int
3664 main ()
3665 {
3666 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3667   ;
3668   return 0;
3669 }
3670 _ACEOF
3671 # Don't try gcc -ansi; that turns off useful extensions and
3672 # breaks some systems' header files.
3673 # AIX                   -qlanglvl=ansi
3674 # Ultrix and OSF/1      -std1
3675 # HP-UX 10.20 and later -Ae
3676 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3677 # SVR4                  -Xc -D__EXTENSIONS__
3678 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3679 do
3680   CC="$ac_save_CC $ac_arg"
3681   rm -f conftest.$ac_objext
3682 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3683   (eval $ac_compile) 2>conftest.er1
3684   ac_status=$?
3685   grep -v '^ *+' conftest.er1 >conftest.err
3686   rm -f conftest.er1
3687   cat conftest.err >&5
3688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3689   (exit $ac_status); } &&
3690          { ac_try='test -z "$ac_c_werror_flag"
3691                          || test ! -s conftest.err'
3692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3693   (eval $ac_try) 2>&5
3694   ac_status=$?
3695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3696   (exit $ac_status); }; } &&
3697          { ac_try='test -s conftest.$ac_objext'
3698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3699   (eval $ac_try) 2>&5
3700   ac_status=$?
3701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3702   (exit $ac_status); }; }; then
3703   ac_cv_prog_cc_stdc=$ac_arg
3704 break
3705 else
3706   echo "$as_me: failed program was:" >&5
3707 sed 's/^/| /' conftest.$ac_ext >&5
3708
3709 fi
3710 rm -f conftest.err conftest.$ac_objext
3711 done
3712 rm -f conftest.$ac_ext conftest.$ac_objext
3713 CC=$ac_save_CC
3714
3715 fi
3716
3717 case "x$ac_cv_prog_cc_stdc" in
3718   x|xno)
3719     echo "$as_me:$LINENO: result: none needed" >&5
3720 echo "${ECHO_T}none needed" >&6 ;;
3721   *)
3722     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3723 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3724     CC="$CC $ac_cv_prog_cc_stdc" ;;
3725 esac
3726
3727 # Some people use a C++ compiler to compile C.  Since we use `exit',
3728 # in C++ we need to declare it.  In case someone uses the same compiler
3729 # for both compiling C and C++ we need to have the C++ compiler decide
3730 # the declaration of exit, since it's the most demanding environment.
3731 cat >conftest.$ac_ext <<_ACEOF
3732 #ifndef __cplusplus
3733   choke me
3734 #endif
3735 _ACEOF
3736 rm -f conftest.$ac_objext
3737 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3738   (eval $ac_compile) 2>conftest.er1
3739   ac_status=$?
3740   grep -v '^ *+' conftest.er1 >conftest.err
3741   rm -f conftest.er1
3742   cat conftest.err >&5
3743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3744   (exit $ac_status); } &&
3745          { ac_try='test -z "$ac_c_werror_flag"
3746                          || test ! -s conftest.err'
3747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3748   (eval $ac_try) 2>&5
3749   ac_status=$?
3750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3751   (exit $ac_status); }; } &&
3752          { ac_try='test -s conftest.$ac_objext'
3753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3754   (eval $ac_try) 2>&5
3755   ac_status=$?
3756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3757   (exit $ac_status); }; }; then
3758   for ac_declaration in \
3759    '' \
3760    'extern "C" void std::exit (int) throw (); using std::exit;' \
3761    'extern "C" void std::exit (int); using std::exit;' \
3762    'extern "C" void exit (int) throw ();' \
3763    'extern "C" void exit (int);' \
3764    'void exit (int);'
3765 do
3766   cat >conftest.$ac_ext <<_ACEOF
3767 /* confdefs.h.  */
3768 _ACEOF
3769 cat confdefs.h >>conftest.$ac_ext
3770 cat >>conftest.$ac_ext <<_ACEOF
3771 /* end confdefs.h.  */
3772 $ac_declaration
3773 #include <stdlib.h>
3774 int
3775 main ()
3776 {
3777 exit (42);
3778   ;
3779   return 0;
3780 }
3781 _ACEOF
3782 rm -f conftest.$ac_objext
3783 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3784   (eval $ac_compile) 2>conftest.er1
3785   ac_status=$?
3786   grep -v '^ *+' conftest.er1 >conftest.err
3787   rm -f conftest.er1
3788   cat conftest.err >&5
3789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3790   (exit $ac_status); } &&
3791          { ac_try='test -z "$ac_c_werror_flag"
3792                          || test ! -s conftest.err'
3793   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3794   (eval $ac_try) 2>&5
3795   ac_status=$?
3796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3797   (exit $ac_status); }; } &&
3798          { ac_try='test -s conftest.$ac_objext'
3799   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3800   (eval $ac_try) 2>&5
3801   ac_status=$?
3802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3803   (exit $ac_status); }; }; then
3804   :
3805 else
3806   echo "$as_me: failed program was:" >&5
3807 sed 's/^/| /' conftest.$ac_ext >&5
3808
3809 continue
3810 fi
3811 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3812   cat >conftest.$ac_ext <<_ACEOF
3813 /* confdefs.h.  */
3814 _ACEOF
3815 cat confdefs.h >>conftest.$ac_ext
3816 cat >>conftest.$ac_ext <<_ACEOF
3817 /* end confdefs.h.  */
3818 $ac_declaration
3819 int
3820 main ()
3821 {
3822 exit (42);
3823   ;
3824   return 0;
3825 }
3826 _ACEOF
3827 rm -f conftest.$ac_objext
3828 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3829   (eval $ac_compile) 2>conftest.er1
3830   ac_status=$?
3831   grep -v '^ *+' conftest.er1 >conftest.err
3832   rm -f conftest.er1
3833   cat conftest.err >&5
3834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3835   (exit $ac_status); } &&
3836          { ac_try='test -z "$ac_c_werror_flag"
3837                          || test ! -s conftest.err'
3838   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3839   (eval $ac_try) 2>&5
3840   ac_status=$?
3841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3842   (exit $ac_status); }; } &&
3843          { ac_try='test -s conftest.$ac_objext'
3844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3845   (eval $ac_try) 2>&5
3846   ac_status=$?
3847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3848   (exit $ac_status); }; }; then
3849   break
3850 else
3851   echo "$as_me: failed program was:" >&5
3852 sed 's/^/| /' conftest.$ac_ext >&5
3853
3854 fi
3855 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3856 done
3857 rm -f conftest*
3858 if test -n "$ac_declaration"; then
3859   echo '#ifdef __cplusplus' >>confdefs.h
3860   echo $ac_declaration      >>confdefs.h
3861   echo '#endif'             >>confdefs.h
3862 fi
3863
3864 else
3865   echo "$as_me: failed program was:" >&5
3866 sed 's/^/| /' conftest.$ac_ext >&5
3867
3868 fi
3869 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3870 ac_ext=c
3871 ac_cpp='$CPP $CPPFLAGS'
3872 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3873 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3874 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3875
3876 ac_ext=cc
3877 ac_cpp='$CXXCPP $CPPFLAGS'
3878 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3879 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3880 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3881 if test -n "$ac_tool_prefix"; then
3882   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3883   do
3884     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3885 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3886 echo "$as_me:$LINENO: checking for $ac_word" >&5
3887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3888 if test "${ac_cv_prog_CXX+set}" = set; then
3889   echo $ECHO_N "(cached) $ECHO_C" >&6
3890 else
3891   if test -n "$CXX"; then
3892   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3893 else
3894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3895 for as_dir in $PATH
3896 do
3897   IFS=$as_save_IFS
3898   test -z "$as_dir" && as_dir=.
3899   for ac_exec_ext in '' $ac_executable_extensions; do
3900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3901     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3903     break 2
3904   fi
3905 done
3906 done
3907
3908 fi
3909 fi
3910 CXX=$ac_cv_prog_CXX
3911 if test -n "$CXX"; then
3912   echo "$as_me:$LINENO: result: $CXX" >&5
3913 echo "${ECHO_T}$CXX" >&6
3914 else
3915   echo "$as_me:$LINENO: result: no" >&5
3916 echo "${ECHO_T}no" >&6
3917 fi
3918
3919     test -n "$CXX" && break
3920   done
3921 fi
3922 if test -z "$CXX"; then
3923   ac_ct_CXX=$CXX
3924   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3925 do
3926   # Extract the first word of "$ac_prog", so it can be a program name with args.
3927 set dummy $ac_prog; ac_word=$2
3928 echo "$as_me:$LINENO: checking for $ac_word" >&5
3929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3930 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3931   echo $ECHO_N "(cached) $ECHO_C" >&6
3932 else
3933   if test -n "$ac_ct_CXX"; then
3934   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3935 else
3936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3937 for as_dir in $PATH
3938 do
3939   IFS=$as_save_IFS
3940   test -z "$as_dir" && as_dir=.
3941   for ac_exec_ext in '' $ac_executable_extensions; do
3942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3943     ac_cv_prog_ac_ct_CXX="$ac_prog"
3944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3945     break 2
3946   fi
3947 done
3948 done
3949
3950 fi
3951 fi
3952 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3953 if test -n "$ac_ct_CXX"; then
3954   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3955 echo "${ECHO_T}$ac_ct_CXX" >&6
3956 else
3957   echo "$as_me:$LINENO: result: no" >&5
3958 echo "${ECHO_T}no" >&6
3959 fi
3960
3961   test -n "$ac_ct_CXX" && break
3962 done
3963 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3964
3965   CXX=$ac_ct_CXX
3966 fi
3967
3968
3969 # Provide some information about the compiler.
3970 echo "$as_me:$LINENO:" \
3971      "checking for C++ compiler version" >&5
3972 ac_compiler=`set X $ac_compile; echo $2`
3973 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3974   (eval $ac_compiler --version </dev/null >&5) 2>&5
3975   ac_status=$?
3976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3977   (exit $ac_status); }
3978 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3979   (eval $ac_compiler -v </dev/null >&5) 2>&5
3980   ac_status=$?
3981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3982   (exit $ac_status); }
3983 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3984   (eval $ac_compiler -V </dev/null >&5) 2>&5
3985   ac_status=$?
3986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3987   (exit $ac_status); }
3988
3989 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3990 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3991 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3992   echo $ECHO_N "(cached) $ECHO_C" >&6
3993 else
3994   cat >conftest.$ac_ext <<_ACEOF
3995 /* confdefs.h.  */
3996 _ACEOF
3997 cat confdefs.h >>conftest.$ac_ext
3998 cat >>conftest.$ac_ext <<_ACEOF
3999 /* end confdefs.h.  */
4000
4001 int
4002 main ()
4003 {
4004 #ifndef __GNUC__
4005        choke me
4006 #endif
4007
4008   ;
4009   return 0;
4010 }
4011 _ACEOF
4012 rm -f conftest.$ac_objext
4013 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4014   (eval $ac_compile) 2>conftest.er1
4015   ac_status=$?
4016   grep -v '^ *+' conftest.er1 >conftest.err
4017   rm -f conftest.er1
4018   cat conftest.err >&5
4019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020   (exit $ac_status); } &&
4021          { ac_try='test -z "$ac_cxx_werror_flag"
4022                          || test ! -s conftest.err'
4023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4024   (eval $ac_try) 2>&5
4025   ac_status=$?
4026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4027   (exit $ac_status); }; } &&
4028          { ac_try='test -s conftest.$ac_objext'
4029   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4030   (eval $ac_try) 2>&5
4031   ac_status=$?
4032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4033   (exit $ac_status); }; }; then
4034   ac_compiler_gnu=yes
4035 else
4036   echo "$as_me: failed program was:" >&5
4037 sed 's/^/| /' conftest.$ac_ext >&5
4038
4039 ac_compiler_gnu=no
4040 fi
4041 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4042 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4043
4044 fi
4045 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4046 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4047 GXX=`test $ac_compiler_gnu = yes && echo yes`
4048 ac_test_CXXFLAGS=${CXXFLAGS+set}
4049 ac_save_CXXFLAGS=$CXXFLAGS
4050 CXXFLAGS="-g"
4051 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4052 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4053 if test "${ac_cv_prog_cxx_g+set}" = set; then
4054   echo $ECHO_N "(cached) $ECHO_C" >&6
4055 else
4056   cat >conftest.$ac_ext <<_ACEOF
4057 /* confdefs.h.  */
4058 _ACEOF
4059 cat confdefs.h >>conftest.$ac_ext
4060 cat >>conftest.$ac_ext <<_ACEOF
4061 /* end confdefs.h.  */
4062
4063 int
4064 main ()
4065 {
4066
4067   ;
4068   return 0;
4069 }
4070 _ACEOF
4071 rm -f conftest.$ac_objext
4072 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4073   (eval $ac_compile) 2>conftest.er1
4074   ac_status=$?
4075   grep -v '^ *+' conftest.er1 >conftest.err
4076   rm -f conftest.er1
4077   cat conftest.err >&5
4078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4079   (exit $ac_status); } &&
4080          { ac_try='test -z "$ac_cxx_werror_flag"
4081                          || test ! -s conftest.err'
4082   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4083   (eval $ac_try) 2>&5
4084   ac_status=$?
4085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4086   (exit $ac_status); }; } &&
4087          { ac_try='test -s conftest.$ac_objext'
4088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4089   (eval $ac_try) 2>&5
4090   ac_status=$?
4091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4092   (exit $ac_status); }; }; then
4093   ac_cv_prog_cxx_g=yes
4094 else
4095   echo "$as_me: failed program was:" >&5
4096 sed 's/^/| /' conftest.$ac_ext >&5
4097
4098 ac_cv_prog_cxx_g=no
4099 fi
4100 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4101 fi
4102 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4103 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4104 if test "$ac_test_CXXFLAGS" = set; then
4105   CXXFLAGS=$ac_save_CXXFLAGS
4106 elif test $ac_cv_prog_cxx_g = yes; then
4107   if test "$GXX" = yes; then
4108     CXXFLAGS="-g -O2"
4109   else
4110     CXXFLAGS="-g"
4111   fi
4112 else
4113   if test "$GXX" = yes; then
4114     CXXFLAGS="-O2"
4115   else
4116     CXXFLAGS=
4117   fi
4118 fi
4119 for ac_declaration in \
4120    '' \
4121    'extern "C" void std::exit (int) throw (); using std::exit;' \
4122    'extern "C" void std::exit (int); using std::exit;' \
4123    'extern "C" void exit (int) throw ();' \
4124    'extern "C" void exit (int);' \
4125    'void exit (int);'
4126 do
4127   cat >conftest.$ac_ext <<_ACEOF
4128 /* confdefs.h.  */
4129 _ACEOF
4130 cat confdefs.h >>conftest.$ac_ext
4131 cat >>conftest.$ac_ext <<_ACEOF
4132 /* end confdefs.h.  */
4133 $ac_declaration
4134 #include <stdlib.h>
4135 int
4136 main ()
4137 {
4138 exit (42);
4139   ;
4140   return 0;
4141 }
4142 _ACEOF
4143 rm -f conftest.$ac_objext
4144 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4145   (eval $ac_compile) 2>conftest.er1
4146   ac_status=$?
4147   grep -v '^ *+' conftest.er1 >conftest.err
4148   rm -f conftest.er1
4149   cat conftest.err >&5
4150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4151   (exit $ac_status); } &&
4152          { ac_try='test -z "$ac_cxx_werror_flag"
4153                          || test ! -s conftest.err'
4154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4155   (eval $ac_try) 2>&5
4156   ac_status=$?
4157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4158   (exit $ac_status); }; } &&
4159          { ac_try='test -s conftest.$ac_objext'
4160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4161   (eval $ac_try) 2>&5
4162   ac_status=$?
4163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4164   (exit $ac_status); }; }; then
4165   :
4166 else
4167   echo "$as_me: failed program was:" >&5
4168 sed 's/^/| /' conftest.$ac_ext >&5
4169
4170 continue
4171 fi
4172 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4173   cat >conftest.$ac_ext <<_ACEOF
4174 /* confdefs.h.  */
4175 _ACEOF
4176 cat confdefs.h >>conftest.$ac_ext
4177 cat >>conftest.$ac_ext <<_ACEOF
4178 /* end confdefs.h.  */
4179 $ac_declaration
4180 int
4181 main ()
4182 {
4183 exit (42);
4184   ;
4185   return 0;
4186 }
4187 _ACEOF
4188 rm -f conftest.$ac_objext
4189 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4190   (eval $ac_compile) 2>conftest.er1
4191   ac_status=$?
4192   grep -v '^ *+' conftest.er1 >conftest.err
4193   rm -f conftest.er1
4194   cat conftest.err >&5
4195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4196   (exit $ac_status); } &&
4197          { ac_try='test -z "$ac_cxx_werror_flag"
4198                          || test ! -s conftest.err'
4199   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4200   (eval $ac_try) 2>&5
4201   ac_status=$?
4202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4203   (exit $ac_status); }; } &&
4204          { ac_try='test -s conftest.$ac_objext'
4205   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4206   (eval $ac_try) 2>&5
4207   ac_status=$?
4208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4209   (exit $ac_status); }; }; then
4210   break
4211 else
4212   echo "$as_me: failed program was:" >&5
4213 sed 's/^/| /' conftest.$ac_ext >&5
4214
4215 fi
4216 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4217 done
4218 rm -f conftest*
4219 if test -n "$ac_declaration"; then
4220   echo '#ifdef __cplusplus' >>confdefs.h
4221   echo $ac_declaration      >>confdefs.h
4222   echo '#endif'             >>confdefs.h
4223 fi
4224
4225 ac_ext=c
4226 ac_cpp='$CPP $CPPFLAGS'
4227 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4228 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4229 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4230
4231
4232 # We must set the default linker to the linker used by gcc for the correct
4233 # operation of libtool.  If LD is not defined and we are using gcc, try to
4234 # set the LD default to the ld used by gcc.
4235 if test -z "$LD"; then
4236   if test "$GCC" = yes; then
4237     case $build in
4238     *-*-mingw*)
4239       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4240     *)
4241       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4242     esac
4243     case $gcc_prog_ld in
4244     # Accept absolute paths.
4245     [\\/]* | [A-Za-z]:[\\/]*)
4246       LD="$gcc_prog_ld" ;;
4247     esac
4248   fi
4249 fi
4250
4251
4252
4253
4254 if test -n "$ac_tool_prefix"; then
4255   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4256 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4257 echo "$as_me:$LINENO: checking for $ac_word" >&5
4258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4259 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4260   echo $ECHO_N "(cached) $ECHO_C" >&6
4261 else
4262   if test -n "$GNATBIND"; then
4263   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4264 else
4265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4266 for as_dir in $PATH
4267 do
4268   IFS=$as_save_IFS
4269   test -z "$as_dir" && as_dir=.
4270   for ac_exec_ext in '' $ac_executable_extensions; do
4271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4272     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4274     break 2
4275   fi
4276 done
4277 done
4278
4279 fi
4280 fi
4281 GNATBIND=$ac_cv_prog_GNATBIND
4282 if test -n "$GNATBIND"; then
4283   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4284 echo "${ECHO_T}$GNATBIND" >&6
4285 else
4286   echo "$as_me:$LINENO: result: no" >&5
4287 echo "${ECHO_T}no" >&6
4288 fi
4289
4290 fi
4291 if test -z "$ac_cv_prog_GNATBIND"; then
4292   ac_ct_GNATBIND=$GNATBIND
4293   # Extract the first word of "gnatbind", so it can be a program name with args.
4294 set dummy gnatbind; ac_word=$2
4295 echo "$as_me:$LINENO: checking for $ac_word" >&5
4296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4297 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4298   echo $ECHO_N "(cached) $ECHO_C" >&6
4299 else
4300   if test -n "$ac_ct_GNATBIND"; then
4301   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4302 else
4303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4304 for as_dir in $PATH
4305 do
4306   IFS=$as_save_IFS
4307   test -z "$as_dir" && as_dir=.
4308   for ac_exec_ext in '' $ac_executable_extensions; do
4309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4310     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4312     break 2
4313   fi
4314 done
4315 done
4316
4317   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4318 fi
4319 fi
4320 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4321 if test -n "$ac_ct_GNATBIND"; then
4322   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4323 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4324 else
4325   echo "$as_me:$LINENO: result: no" >&5
4326 echo "${ECHO_T}no" >&6
4327 fi
4328
4329   GNATBIND=$ac_ct_GNATBIND
4330 else
4331   GNATBIND="$ac_cv_prog_GNATBIND"
4332 fi
4333
4334 if test -n "$ac_tool_prefix"; then
4335   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4336 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4337 echo "$as_me:$LINENO: checking for $ac_word" >&5
4338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4339 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4340   echo $ECHO_N "(cached) $ECHO_C" >&6
4341 else
4342   if test -n "$GNATMAKE"; then
4343   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4344 else
4345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4346 for as_dir in $PATH
4347 do
4348   IFS=$as_save_IFS
4349   test -z "$as_dir" && as_dir=.
4350   for ac_exec_ext in '' $ac_executable_extensions; do
4351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4352     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4354     break 2
4355   fi
4356 done
4357 done
4358
4359 fi
4360 fi
4361 GNATMAKE=$ac_cv_prog_GNATMAKE
4362 if test -n "$GNATMAKE"; then
4363   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4364 echo "${ECHO_T}$GNATMAKE" >&6
4365 else
4366   echo "$as_me:$LINENO: result: no" >&5
4367 echo "${ECHO_T}no" >&6
4368 fi
4369
4370 fi
4371 if test -z "$ac_cv_prog_GNATMAKE"; then
4372   ac_ct_GNATMAKE=$GNATMAKE
4373   # Extract the first word of "gnatmake", so it can be a program name with args.
4374 set dummy gnatmake; ac_word=$2
4375 echo "$as_me:$LINENO: checking for $ac_word" >&5
4376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4377 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4378   echo $ECHO_N "(cached) $ECHO_C" >&6
4379 else
4380   if test -n "$ac_ct_GNATMAKE"; then
4381   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4382 else
4383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4384 for as_dir in $PATH
4385 do
4386   IFS=$as_save_IFS
4387   test -z "$as_dir" && as_dir=.
4388   for ac_exec_ext in '' $ac_executable_extensions; do
4389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4390     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4392     break 2
4393   fi
4394 done
4395 done
4396
4397   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4398 fi
4399 fi
4400 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4401 if test -n "$ac_ct_GNATMAKE"; then
4402   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4403 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4404 else
4405   echo "$as_me:$LINENO: result: no" >&5
4406 echo "${ECHO_T}no" >&6
4407 fi
4408
4409   GNATMAKE=$ac_ct_GNATMAKE
4410 else
4411   GNATMAKE="$ac_cv_prog_GNATMAKE"
4412 fi
4413
4414 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4415 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4416 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4417   echo $ECHO_N "(cached) $ECHO_C" >&6
4418 else
4419   cat >conftest.adb <<EOF
4420 procedure conftest is begin null; end conftest;
4421 EOF
4422 acx_cv_cc_gcc_supports_ada=no
4423 # There is a bug in old released versions of GCC which causes the
4424 # driver to exit successfully when the appropriate language module
4425 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4426 # Therefore we must check for the error message as well as an
4427 # unsuccessful exit.
4428 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4429 # given a .adb file, but produce no object file.  So we must check
4430 # if an object file was really produced to guard against this.
4431 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4432 if test x"$errors" = x && test -f conftest.$ac_objext; then
4433   acx_cv_cc_gcc_supports_ada=yes
4434 fi
4435 rm -f conftest.*
4436 fi
4437 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4438 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4439
4440 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4441   have_gnat=yes
4442 else
4443   have_gnat=no
4444 fi
4445
4446 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4447 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4448 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4449   echo $ECHO_N "(cached) $ECHO_C" >&6
4450 else
4451    echo abfoo >t1
4452   echo cdfoo >t2
4453   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4454   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4455     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4456       :
4457     else
4458       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4459     fi
4460   fi
4461   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4462     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4463       :
4464     else
4465       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4466     fi
4467   fi
4468   rm t1 t2
4469
4470 fi
4471 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4472 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4473 do_compare="$gcc_cv_prog_cmp_skip"
4474
4475
4476
4477 # Check for GMP and MPFR
4478 gmplibs="-lmpfr -lgmp"
4479 gmpinc=
4480 have_gmp=no
4481
4482 # Specify a location for mpfr
4483 # check for this first so it ends up on the link line before gmp.
4484
4485 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4486 if test "${with_mpfr_dir+set}" = set; then
4487   withval="$with_mpfr_dir"
4488   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4489 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4490 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4491 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4492    { (exit 1); exit 1; }; }
4493 fi;
4494
4495
4496 # Check whether --with-mpfr or --without-mpfr was given.
4497 if test "${with_mpfr+set}" = set; then
4498   withval="$with_mpfr"
4499
4500 fi;
4501
4502 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4503 if test "${with_mpfr_include+set}" = set; then
4504   withval="$with_mpfr_include"
4505
4506 fi;
4507
4508 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4509 if test "${with_mpfr_lib+set}" = set; then
4510   withval="$with_mpfr_lib"
4511
4512 fi;
4513
4514 if test "x$with_mpfr" != x; then
4515   gmplibs="-L$with_mpfr/lib $gmplibs"
4516   gmpinc="-I$with_mpfr/include"
4517 fi
4518 if test "x$with_mpfr_include" != x; then
4519   gmpinc="-I$with_mpfr_include"
4520 fi
4521 if test "x$with_mpfr_lib" != x; then
4522   gmplibs="-L$with_mpfr_lib $gmplibs"
4523 fi
4524 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4525   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4526   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4527   # Do not test the mpfr version.  Assume that it is sufficient, since
4528   # it is in the source tree, and the library has not been built yet
4529   # but it would be included on the link line in the version check below
4530   # hence making the test fail.
4531   have_gmp=yes
4532 fi
4533
4534 # Specify a location for gmp
4535
4536 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4537 if test "${with_gmp_dir+set}" = set; then
4538   withval="$with_gmp_dir"
4539   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4540 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4541 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4542 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4543    { (exit 1); exit 1; }; }
4544 fi;
4545
4546
4547 # Check whether --with-gmp or --without-gmp was given.
4548 if test "${with_gmp+set}" = set; then
4549   withval="$with_gmp"
4550
4551 fi;
4552
4553 # Check whether --with-gmp_include or --without-gmp_include was given.
4554 if test "${with_gmp_include+set}" = set; then
4555   withval="$with_gmp_include"
4556
4557 fi;
4558
4559 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4560 if test "${with_gmp_lib+set}" = set; then
4561   withval="$with_gmp_lib"
4562
4563 fi;
4564
4565
4566 if test "x$with_gmp" != x; then
4567   gmplibs="-L$with_gmp/lib $gmplibs"
4568   gmpinc="-I$with_gmp/include $gmpinc"
4569 fi
4570 if test "x$with_gmp_include" != x; then
4571   gmpinc="-I$with_gmp_include $gmpinc"
4572 fi
4573 if test "x$with_gmp_lib" != x; then
4574   gmplibs="-L$with_gmp_lib $gmplibs"
4575 fi
4576 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4577   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4578   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4579   # Do not test the gmp version.  Assume that it is sufficient, since
4580   # it is in the source tree, and the library has not been built yet
4581   # but it would be included on the link line in the version check below
4582   # hence making the test fail.
4583   have_gmp=yes
4584 fi
4585
4586 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4587   have_gmp=yes
4588   saved_CFLAGS="$CFLAGS"
4589   CFLAGS="$CFLAGS $gmpinc"
4590   # Check GMP actually works
4591   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4592 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4593
4594 cat >conftest.$ac_ext <<_ACEOF
4595 /* confdefs.h.  */
4596 _ACEOF
4597 cat confdefs.h >>conftest.$ac_ext
4598 cat >>conftest.$ac_ext <<_ACEOF
4599 /* end confdefs.h.  */
4600 #include "gmp.h"
4601 int
4602 main ()
4603 {
4604
4605   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4606   choke me
4607   #endif
4608
4609   ;
4610   return 0;
4611 }
4612 _ACEOF
4613 rm -f conftest.$ac_objext
4614 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4615   (eval $ac_compile) 2>conftest.er1
4616   ac_status=$?
4617   grep -v '^ *+' conftest.er1 >conftest.err
4618   rm -f conftest.er1
4619   cat conftest.err >&5
4620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4621   (exit $ac_status); } &&
4622          { ac_try='test -z "$ac_c_werror_flag"
4623                          || test ! -s conftest.err'
4624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4625   (eval $ac_try) 2>&5
4626   ac_status=$?
4627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4628   (exit $ac_status); }; } &&
4629          { ac_try='test -s conftest.$ac_objext'
4630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4631   (eval $ac_try) 2>&5
4632   ac_status=$?
4633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4634   (exit $ac_status); }; }; then
4635   echo "$as_me:$LINENO: result: yes" >&5
4636 echo "${ECHO_T}yes" >&6
4637 else
4638   echo "$as_me: failed program was:" >&5
4639 sed 's/^/| /' conftest.$ac_ext >&5
4640
4641 echo "$as_me:$LINENO: result: no" >&5
4642 echo "${ECHO_T}no" >&6; have_gmp=no
4643 fi
4644 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4645
4646   if test x"$have_gmp" = xyes; then
4647     saved_LIBS="$LIBS"
4648     LIBS="$LIBS $gmplibs"
4649         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4650 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4651     cat >conftest.$ac_ext <<_ACEOF
4652 /* confdefs.h.  */
4653 _ACEOF
4654 cat confdefs.h >>conftest.$ac_ext
4655 cat >>conftest.$ac_ext <<_ACEOF
4656 /* end confdefs.h.  */
4657 #include <gmp.h>
4658     #include <mpfr.h>
4659 int
4660 main ()
4661 {
4662
4663     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4664     choke me
4665     #endif
4666     mpfr_t n;
4667     mpfr_t x;
4668     int t;
4669     mpfr_init (n);
4670     mpfr_init (x);
4671     mpfr_atan2 (n, n, x, GMP_RNDN);
4672     mpfr_erfc (n, x, GMP_RNDN);
4673     mpfr_subnormalize (x, t, GMP_RNDN);
4674
4675   ;
4676   return 0;
4677 }
4678 _ACEOF
4679 rm -f conftest.$ac_objext conftest$ac_exeext
4680 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4681   (eval $ac_link) 2>conftest.er1
4682   ac_status=$?
4683   grep -v '^ *+' conftest.er1 >conftest.err
4684   rm -f conftest.er1
4685   cat conftest.err >&5
4686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4687   (exit $ac_status); } &&
4688          { ac_try='test -z "$ac_c_werror_flag"
4689                          || test ! -s conftest.err'
4690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4691   (eval $ac_try) 2>&5
4692   ac_status=$?
4693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4694   (exit $ac_status); }; } &&
4695          { ac_try='test -s conftest$ac_exeext'
4696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4697   (eval $ac_try) 2>&5
4698   ac_status=$?
4699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4700   (exit $ac_status); }; }; then
4701   cat >conftest.$ac_ext <<_ACEOF
4702 /* confdefs.h.  */
4703 _ACEOF
4704 cat confdefs.h >>conftest.$ac_ext
4705 cat >>conftest.$ac_ext <<_ACEOF
4706 /* end confdefs.h.  */
4707 #include <gmp.h>
4708     #include <mpfr.h>
4709 int
4710 main ()
4711 {
4712
4713     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4714     choke me
4715     #endif
4716     mpfr_t n; mpfr_init(n);
4717
4718   ;
4719   return 0;
4720 }
4721 _ACEOF
4722 rm -f conftest.$ac_objext conftest$ac_exeext
4723 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4724   (eval $ac_link) 2>conftest.er1
4725   ac_status=$?
4726   grep -v '^ *+' conftest.er1 >conftest.err
4727   rm -f conftest.er1
4728   cat conftest.err >&5
4729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4730   (exit $ac_status); } &&
4731          { ac_try='test -z "$ac_c_werror_flag"
4732                          || test ! -s conftest.err'
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); }; } &&
4738          { ac_try='test -s conftest$ac_exeext'
4739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4740   (eval $ac_try) 2>&5
4741   ac_status=$?
4742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4743   (exit $ac_status); }; }; then
4744   echo "$as_me:$LINENO: result: yes" >&5
4745 echo "${ECHO_T}yes" >&6
4746 else
4747   echo "$as_me: failed program was:" >&5
4748 sed 's/^/| /' conftest.$ac_ext >&5
4749
4750 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4751 echo "${ECHO_T}buggy but acceptable" >&6
4752 fi
4753 rm -f conftest.err conftest.$ac_objext \
4754       conftest$ac_exeext conftest.$ac_ext
4755 else
4756   echo "$as_me: failed program was:" >&5
4757 sed 's/^/| /' conftest.$ac_ext >&5
4758
4759 echo "$as_me:$LINENO: result: no" >&5
4760 echo "${ECHO_T}no" >&6; have_gmp=no
4761 fi
4762 rm -f conftest.err conftest.$ac_objext \
4763       conftest$ac_exeext conftest.$ac_ext
4764       LIBS="$saved_LIBS"
4765   fi
4766   CFLAGS="$saved_CFLAGS"
4767
4768   if test x$have_gmp != xyes; then
4769     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4770 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4771 Copies of these libraries' source code can be found at their respective
4772 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4773 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4774 If you obtained GMP and/or MPFR from a vendor distribution package, make
4775 sure that you have installed both the libraries and the header files.
4776 They may be located in separate packages." >&5
4777 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4778 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4779 Copies of these libraries' source code can be found at their respective
4780 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4781 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4782 If you obtained GMP and/or MPFR from a vendor distribution package, make
4783 sure that you have installed both the libraries and the header files.
4784 They may be located in separate packages." >&2;}
4785    { (exit 1); exit 1; }; }
4786   fi
4787 fi
4788
4789 # Flags needed for both GMP and/or MPFR
4790
4791
4792
4793 # By default, C is the only stage 1 language.
4794 stage1_languages=,c,
4795
4796 # Figure out what language subdirectories are present.
4797 # Look if the user specified --enable-languages="..."; if not, use
4798 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4799 # go away some day.
4800 # NB:  embedded tabs in this IF block -- do not untabify
4801 if test -d ${srcdir}/gcc; then
4802   if test x"${enable_languages+set}" != xset; then
4803     if test x"${LANGUAGES+set}" = xset; then
4804       enable_languages="${LANGUAGES}"
4805         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4806     else
4807       enable_languages=all
4808     fi
4809   else
4810     if test x"${enable_languages}" = x ||
4811        test x"${enable_languages}" = xyes;
4812        then
4813       echo configure.in: --enable-languages needs at least one language argument 1>&2
4814       exit 1
4815     fi
4816   fi
4817   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4818
4819   # 'f95' is the old name for the 'fortran' language. We issue a warning
4820   # and make the substitution.
4821   case ,${enable_languages}, in
4822     *,f95,*)
4823       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4824       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4825       ;;
4826   esac
4827
4828   # First scan to see if an enabled language requires some other language.
4829   # We assume that a given config-lang.in will list all the language
4830   # front ends it requires, even if some are required indirectly.
4831   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4832     case ${lang_frag} in
4833       ..) ;;
4834       # The odd quoting in the next line works around
4835       # an apparent bug in bash 1.12 on linux.
4836       ${srcdir}/gcc/[*]/config-lang.in) ;;
4837       *)
4838         # From the config-lang.in, get $language, $lang_requires
4839         language=
4840         lang_requires=
4841         . ${lang_frag}
4842         for other in ${lang_requires} ; do
4843           case ,${enable_languages}, in
4844             *,$other,*) ;;
4845             *,all,*) ;;
4846             *,$language,*)
4847               echo " \`$other' language required by \`$language'; enabling" 1>&2
4848               enable_languages="${enable_languages},${other}"
4849               ;;
4850           esac
4851         done
4852         ;;
4853     esac
4854   done
4855
4856   new_enable_languages=,c,
4857   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4858   potential_languages=,c,
4859
4860   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4861     case ${lang_frag} in
4862       ..) ;;
4863       # The odd quoting in the next line works around
4864       # an apparent bug in bash 1.12 on linux.
4865       ${srcdir}/gcc/[*]/config-lang.in) ;;
4866       *)
4867         # From the config-lang.in, get $language, $target_libs,
4868         # $lang_dirs, $boot_language, and $build_by_default
4869         language=
4870         target_libs=
4871         lang_dirs=
4872         subdir_requires=
4873         boot_language=no
4874         build_by_default=yes
4875         . ${lang_frag}
4876         if test x${language} = x; then
4877           echo "${lang_frag} doesn't set \$language." 1>&2
4878           exit 1
4879         fi
4880
4881         case ,${enable_languages}, in
4882           *,${language},*)
4883             # Language was explicitly selected; include it.
4884             add_this_lang=yes
4885             ;;
4886           *,all,*)
4887             # 'all' was selected, select it if it is a default language
4888             add_this_lang=${build_by_default}
4889             ;;
4890           *)
4891             add_this_lang=no
4892             ;;
4893         esac
4894
4895         # Disable languages that need other directories if these aren't available.
4896         for i in $subdir_requires; do
4897           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4898           case ,${enable_languages}, in
4899             *,${language},*)
4900               # Specifically requested language; tell them.
4901               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4902 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4903    { (exit 1); exit 1; }; }
4904               ;;
4905             *)
4906               # Silently disable.
4907               add_this_lang=unsupported
4908               ;;
4909           esac
4910         done
4911
4912         # Disable Ada if no preexisting GNAT is available.
4913         case ,${enable_languages},:${language}:${have_gnat} in
4914           *,${language},*:ada:no)
4915             # Specifically requested language; tell them.
4916             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4917 echo "$as_me: error: GNAT is required to build $language" >&2;}
4918    { (exit 1); exit 1; }; }
4919             ;;
4920           *:ada:no)
4921             # Silently disable.
4922             add_this_lang=unsupported
4923             ;;
4924         esac
4925
4926         # Disable a language that is unsupported by the target.
4927         case " $unsupported_languages " in
4928           *" $language "*)
4929             add_this_lang=unsupported
4930             ;;
4931         esac
4932
4933         case $add_this_lang in
4934           unsupported)
4935             # Remove language-dependent dirs.
4936             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4937             ;;
4938           no)
4939             # Remove language-dependent dirs; still show language as supported.
4940             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4941             potential_languages="${potential_languages}${language},"
4942             ;;
4943           yes)
4944             new_enable_languages="${new_enable_languages}${language},"
4945             potential_languages="${potential_languages}${language},"
4946             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4947             case ${boot_language} in
4948               yes)
4949                 # Add to (comma-separated) list of stage 1 languages.
4950                 stage1_languages="${stage1_languages}${language},"
4951                 ;;
4952             esac
4953             ;;
4954         esac
4955         ;;
4956     esac
4957   done
4958
4959   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4960 if test "${enable_stage1_languages+set}" = set; then
4961   enableval="$enable_stage1_languages"
4962   case ,${enable_stage1_languages}, in
4963     ,no,|,,)
4964       # Set it to something that will have no effect in the loop below
4965       enable_stage1_languages=c ;;
4966     ,yes,)
4967       enable_stage1_languages=`echo $new_enable_languages | \
4968         sed -e "s/^,//" -e "s/,$//" ` ;;
4969     *,all,*)
4970       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4971         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4972   esac
4973
4974   # Add "good" languages from enable_stage1_languages to stage1_languages,
4975   # while "bad" languages go in missing_languages.  Leave no duplicates.
4976   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4977     case $potential_languages in
4978       *,$i,*)
4979         case $stage1_languages in
4980           *,$i,*) ;;
4981           *) stage1_languages="$stage1_languages$i," ;;
4982         esac ;;
4983       *)
4984         case $missing_languages in
4985           *,$i,*) ;;
4986           *) missing_languages="$missing_languages$i," ;;
4987         esac ;;
4988      esac
4989   done
4990 fi;
4991
4992   # Remove leading/trailing commas that were added for simplicity
4993   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4994   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4995   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4996   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4997
4998   if test "x$missing_languages" != x; then
4999     { { echo "$as_me:$LINENO: error:
5000 The following requested languages could not be built: ${missing_languages}
5001 Supported languages are: ${potential_languages}" >&5
5002 echo "$as_me: error:
5003 The following requested languages could not be built: ${missing_languages}
5004 Supported languages are: ${potential_languages}" >&2;}
5005    { (exit 1); exit 1; }; }
5006   fi
5007   if test "x$new_enable_languages" != "x$enable_languages"; then
5008     echo The following languages will be built: ${new_enable_languages}
5009     enable_languages="$new_enable_languages"
5010   fi
5011
5012
5013   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5014 fi
5015
5016 # Handle --disable-<component> generically.
5017 for dir in $configdirs $build_configdirs $target_configdirs ; do
5018   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5019   varname=`echo $dirname | sed -e s/+/_/g`
5020   if eval test x\${enable_${varname}} "=" xno ; then
5021     noconfigdirs="$noconfigdirs $dir"
5022   fi
5023 done
5024
5025 # Check for Boehm's garbage collector
5026 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5027 if test "${enable_objc_gc+set}" = set; then
5028   enableval="$enable_objc_gc"
5029   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5030   *,objc,*:*:yes:*target-boehm-gc*)
5031     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5032 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5033    { (exit 1); exit 1; }; }
5034     ;;
5035 esac
5036 fi;
5037
5038 # Make sure we only build Boehm's garbage collector if required.
5039 case ,${enable_languages},:${enable_objc_gc} in
5040   *,objc,*:yes)
5041     # Keep target-boehm-gc if requested for Objective-C.
5042     ;;
5043   *)
5044     # Otherwise remove target-boehm-gc depending on target-libjava.
5045     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5046       noconfigdirs="$noconfigdirs target-boehm-gc"
5047     fi
5048     ;;
5049 esac
5050
5051 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5052 # $build_configdirs and $target_configdirs.
5053 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5054
5055 notsupp=""
5056 for dir in . $skipdirs $noconfigdirs ; do
5057   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5058   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5059     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5060     if test -r $srcdir/$dirname/configure ; then
5061       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5062         true
5063       else
5064         notsupp="$notsupp $dir"
5065       fi
5066     fi
5067   fi
5068   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5069     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5070     if test -r $srcdir/$dirname/configure ; then
5071       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5072         true
5073       else
5074         notsupp="$notsupp $dir"
5075       fi
5076     fi
5077   fi
5078   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5079     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5080     if test -r $srcdir/$dirname/configure ; then
5081       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5082         true
5083       else
5084         notsupp="$notsupp $dir"
5085       fi
5086     fi
5087   fi
5088 done
5089
5090 # Sometimes the tools are distributed with libiberty but with no other
5091 # libraries.  In that case, we don't want to build target-libiberty.
5092 # Don't let libgcc imply libiberty either.
5093 if test -n "${target_configdirs}" ; then
5094   libgcc=
5095   others=
5096   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5097     if test "$i" = "libgcc"; then
5098       libgcc=target-libgcc
5099     elif test "$i" != "libiberty" ; then
5100       if test -r $srcdir/$i/configure ; then
5101         others=yes;
5102         break;
5103       fi
5104     fi
5105   done
5106   if test -z "${others}" ; then
5107     target_configdirs=$libgcc
5108   fi
5109 fi
5110
5111 # Quietly strip out all directories which aren't configurable in this tree.
5112 # This relies on all configurable subdirectories being autoconfiscated, which
5113 # is now the case.
5114 build_configdirs_all="$build_configdirs"
5115 build_configdirs=
5116 for i in ${build_configdirs_all} ; do
5117   j=`echo $i | sed -e s/build-//g`
5118   if test -f ${srcdir}/$j/configure ; then
5119     build_configdirs="${build_configdirs} $i"
5120   fi
5121 done
5122
5123 configdirs_all="$configdirs"
5124 configdirs=
5125 for i in ${configdirs_all} ; do
5126   if test -f ${srcdir}/$i/configure ; then
5127     configdirs="${configdirs} $i"
5128   fi
5129 done
5130
5131 target_configdirs_all="$target_configdirs"
5132 target_configdirs=
5133 for i in ${target_configdirs_all} ; do
5134   j=`echo $i | sed -e s/target-//g`
5135   if test -f ${srcdir}/$j/configure ; then
5136     target_configdirs="${target_configdirs} $i"
5137   fi
5138 done
5139
5140 # Produce a warning message for the subdirs we can't configure.
5141 # This isn't especially interesting in the Cygnus tree, but in the individual
5142 # FSF releases, it's important to let people know when their machine isn't
5143 # supported by the one or two programs in a package.
5144
5145 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5146   # If $appdirs is non-empty, at least one of those directories must still
5147   # be configured, or we error out.  (E.g., if the gas release supports a
5148   # specified target in some subdirs but not the gas subdir, we shouldn't
5149   # pretend that all is well.)
5150   if test -n "$appdirs" ; then
5151     for dir in $appdirs ; do
5152       if test -r $dir/Makefile.in ; then
5153         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5154           appdirs=""
5155           break
5156         fi
5157         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5158           appdirs=""
5159           break
5160         fi
5161       fi
5162     done
5163     if test -n "$appdirs" ; then
5164       echo "*** This configuration is not supported by this package." 1>&2
5165       exit 1
5166     fi
5167   fi
5168   # Okay, some application will build, or we don't care to check.  Still
5169   # notify of subdirs not getting built.
5170   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5171   echo "    ${notsupp}" 1>&2
5172   echo "    (Any other directories should still work fine.)" 1>&2
5173 fi
5174
5175 case "$host" in
5176   *msdosdjgpp*)
5177     enable_gdbtk=no ;;
5178 esac
5179
5180 # To find our prefix, in gcc_cv_tool_prefix.
5181
5182 # The user is always right.
5183 if test "${PATH_SEPARATOR+set}" != set; then
5184   echo "#! /bin/sh" >conf$$.sh
5185   echo  "exit 0"   >>conf$$.sh
5186   chmod +x conf$$.sh
5187   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5188     PATH_SEPARATOR=';'
5189   else
5190     PATH_SEPARATOR=:
5191   fi
5192   rm -f conf$$.sh
5193 fi
5194
5195
5196
5197 if test "x$exec_prefix" = xNONE; then
5198         if test "x$prefix" = xNONE; then
5199                 gcc_cv_tool_prefix=$ac_default_prefix
5200         else
5201                 gcc_cv_tool_prefix=$prefix
5202         fi
5203 else
5204         gcc_cv_tool_prefix=$exec_prefix
5205 fi
5206
5207 # If there is no compiler in the tree, use the PATH only.  In any
5208 # case, if there is no compiler in the tree nobody should use
5209 # AS_FOR_TARGET and LD_FOR_TARGET.
5210 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5211     gcc_version=`cat $srcdir/gcc/BASE-VER`
5212     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5213     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5214     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5215     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5216     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5217     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5218 else
5219     gcc_cv_tool_dirs=
5220 fi
5221
5222 if test x$build = x$target && test -n "$md_exec_prefix"; then
5223         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5224 fi
5225
5226
5227
5228 copy_dirs=
5229
5230
5231 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5232 if test "${with_build_sysroot+set}" = set; then
5233   withval="$with_build_sysroot"
5234   if test x"$withval" != x ; then
5235      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5236    fi
5237 else
5238   SYSROOT_CFLAGS_FOR_TARGET=
5239 fi;
5240
5241
5242
5243 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5244 if test "${with_debug_prefix_map+set}" = set; then
5245   withval="$with_debug_prefix_map"
5246   if test x"$withval" != x; then
5247      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5248      for debug_map in $withval; do
5249        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5250      done
5251    fi
5252 else
5253   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5254 fi;
5255
5256
5257 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5258 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5259 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5260 # We want to ensure that TARGET libraries (which we know are built with
5261 # gcc) are built with "-O2 -g", so include those options when setting
5262 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5263 if test "x$CFLAGS_FOR_TARGET" = x; then
5264   CFLAGS_FOR_TARGET=$CFLAGS
5265   case " $CFLAGS " in
5266     *" -O2 "*) ;;
5267     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5268   esac
5269   case " $CFLAGS " in
5270     *" -g "* | *" -g3 "*) ;;
5271     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5272   esac
5273 fi
5274
5275
5276 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5277   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5278   case " $CXXFLAGS " in
5279     *" -O2 "*) ;;
5280     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5281   esac
5282   case " $CXXFLAGS " in
5283     *" -g "* | *" -g3 "*) ;;
5284     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5285   esac
5286 fi
5287
5288
5289 # Other target tools.
5290 CPPFLAGS_FOR_TARGET=${CPPFLAGS_FOR_TARGET-${CPPFLAGS}}
5291
5292 LDFLAGS_FOR_TARGET=${LDFLAGS_FOR_TARGET-${LDFLAGS}}
5293
5294
5295 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5296 # the named directory are copied to $(tooldir)/sys-include.
5297 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5298   if test x${is_cross_compiler} = xno ; then
5299     echo 1>&2 '***' --with-headers is only supported when cross compiling
5300     exit 1
5301   fi
5302   if test x"${with_headers}" != xyes ; then
5303     x=${gcc_cv_tool_prefix}
5304     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5305   fi
5306 fi
5307
5308 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5309 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5310 # are permitted.
5311 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5312   if test x${is_cross_compiler} = xno ; then
5313     echo 1>&2 '***' --with-libs is only supported when cross compiling
5314     exit 1
5315   fi
5316   if test x"${with_libs}" != xyes ; then
5317     # Copy the libraries in reverse order, so that files in the first named
5318     # library override files in subsequent libraries.
5319     x=${gcc_cv_tool_prefix}
5320     for l in ${with_libs}; do
5321       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5322     done
5323   fi
5324 fi
5325
5326 # Set with_gnu_as and with_gnu_ld as appropriate.
5327 #
5328 # This is done by determining whether or not the appropriate directory
5329 # is available, and by checking whether or not specific configurations
5330 # have requested that this magic not happen.
5331 #
5332 # The command line options always override the explicit settings in
5333 # configure.in, and the settings in configure.in override this magic.
5334 #
5335 # If the default for a toolchain is to use GNU as and ld, and you don't
5336 # want to do that, then you should use the --without-gnu-as and
5337 # --without-gnu-ld options for the configure script.
5338
5339 if test x${use_gnu_as} = x &&
5340    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5341   with_gnu_as=yes
5342   extra_host_args="$extra_host_args --with-gnu-as"
5343 fi
5344
5345 if test x${use_gnu_ld} = x &&
5346    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5347   with_gnu_ld=yes
5348   extra_host_args="$extra_host_args --with-gnu-ld"
5349 fi
5350
5351 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5352 # can detect this case.
5353
5354 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5355   with_newlib=yes
5356   extra_host_args="$extra_host_args --with-newlib"
5357 fi
5358
5359 # Handle ${copy_dirs}
5360 set fnord ${copy_dirs}
5361 shift
5362 while test $# != 0 ; do
5363   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5364     :
5365   else
5366     echo Copying $1 to $2
5367
5368     # Use the install script to create the directory and all required
5369     # parent directories.
5370     if test -d $2 ; then
5371       :
5372     else
5373       echo >config.temp
5374       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5375     fi
5376
5377     # Copy the directory, assuming we have tar.
5378     # FIXME: Should we use B in the second tar?  Not all systems support it.
5379     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5380
5381     # It is the responsibility of the user to correctly adjust all
5382     # symlinks.  If somebody can figure out how to handle them correctly
5383     # here, feel free to add the code.
5384
5385     echo $1 > $2/COPIED
5386   fi
5387   shift; shift
5388 done
5389
5390 # Determine a target-dependent exec_prefix that the installed
5391 # gcc will search in.  Keep this list sorted by triplet, with
5392 # the *-*-osname triplets last.
5393 md_exec_prefix=
5394 case "${target}" in
5395   alpha*-*-*vms*)
5396     md_exec_prefix=/gnu/lib/gcc-lib
5397     ;;
5398   i[34567]86-pc-msdosdjgpp*)
5399     md_exec_prefix=/dev/env/DJDIR/bin
5400     ;;
5401   i[34567]86-*-sco3.2v5*)
5402     if test $with_gnu_as = yes; then
5403       md_exec_prefix=/usr/gnu/bin
5404     else
5405       md_exec_prefix=/usr/ccs/bin/elf
5406     fi
5407     ;;
5408
5409   mn10300-*-* | \
5410   powerpc-*-chorusos* | \
5411   powerpc*-*-eabi* | \
5412   powerpc*-*-sysv* | \
5413   powerpc*-*-kaos* | \
5414   s390x-ibm-tpf*)
5415     md_exec_prefix=/usr/ccs/bin
5416     ;;
5417   sparc64-*-elf*)
5418     ;;
5419   v850*-*-*)
5420     md_exec_prefix=/usr/ccs/bin
5421     ;;
5422   xtensa*-*-elf*)
5423     ;;
5424
5425   *-*-beos* | \
5426   *-*-elf* | \
5427   *-*-hpux* | \
5428   *-*-netware* | \
5429   *-*-nto-qnx* | \
5430   *-*-rtems* | \
5431   *-*-solaris2* | \
5432   *-*-sysv[45]* | \
5433   *-*-vxworks* | \
5434   *-wrs-windiss)
5435     md_exec_prefix=/usr/ccs/bin
5436     ;;
5437 esac
5438
5439 extra_arflags_for_target=
5440 extra_nmflags_for_target=
5441 extra_ranlibflags_for_target=
5442 target_makefile_frag=/dev/null
5443 case "${target}" in
5444   mep*-*-*)
5445     target_makefile_frag="config/mt-mep"
5446     ;;
5447   spu-*-*)
5448     target_makefile_frag="config/mt-spu"
5449     ;;
5450   mips*-sde-elf*)
5451     target_makefile_frag="config/mt-sde"
5452     ;;
5453   mipsisa*-*-elfoabi*)
5454     target_makefile_frag="config/mt-mips-elfoabi"
5455     ;;
5456   mips*-*-*linux* | mips*-*-gnu*)
5457     target_makefile_frag="config/mt-mips-gnu"
5458     ;;
5459   *-*-netware*)
5460     target_makefile_frag="config/mt-netware"
5461     ;;
5462   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5463     target_makefile_frag="config/mt-gnu"
5464     ;;
5465   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5466     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5467     # commands to handle both 32-bit and 64-bit objects.  These flags are
5468     # harmless if we're using GNU nm or ar.
5469     extra_arflags_for_target=" -X32_64"
5470     extra_nmflags_for_target=" -B -X32_64"
5471     ;;
5472   *-*-darwin*)
5473     # ranlib from Darwin requires the -c flag to look at common symbols.
5474     extra_ranlibflags_for_target=" -c"
5475     ;;
5476   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5477     target_makefile_frag="config/mt-wince"
5478     ;;
5479 esac
5480
5481 alphaieee_frag=/dev/null
5482 case $target in
5483   alpha*-*-*)
5484     # This just makes sure to use the -mieee option to build target libs.
5485     # This should probably be set individually by each library.
5486     alphaieee_frag="config/mt-alphaieee"
5487     ;;
5488 esac
5489
5490 # If --enable-target-optspace always use -Os instead of -O2 to build
5491 # the target libraries, similarly if it is not specified, use -Os
5492 # on selected platforms.
5493 ospace_frag=/dev/null
5494 case "${enable_target_optspace}:${target}" in
5495   yes:*)
5496     ospace_frag="config/mt-ospace"
5497     ;;
5498   :d30v-*)
5499     ospace_frag="config/mt-d30v"
5500     ;;
5501   :m32r-* | :d10v-* | :fr30-*)
5502     ospace_frag="config/mt-ospace"
5503     ;;
5504   no:* | :*)
5505     ;;
5506   *)
5507     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5508     ;;
5509 esac
5510
5511 # Default to using --with-stabs for certain targets.
5512 if test x${with_stabs} = x ; then
5513   case "${target}" in
5514   mips*-*-irix[56]*)
5515     ;;
5516   mips*-*-* | alpha*-*-osf*)
5517     with_stabs=yes;
5518     extra_host_args="${extra_host_args} --with-stabs"
5519     ;;
5520   esac
5521 fi
5522
5523 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5524 # them automatically.
5525 case "${host}" in
5526   hppa*64*-*-hpux11*)
5527     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5528     ;;
5529 esac
5530
5531 # Some systems (e.g., one of the i386-aix systems the gas testers are
5532 # using) don't handle "\$" correctly, so don't use it here.
5533 tooldir='${exec_prefix}'/${target_noncanonical}
5534 build_tooldir=${tooldir}
5535
5536 # Create a .gdbinit file which runs the one in srcdir
5537 # and tells GDB to look there for source files.
5538
5539 if test -r ${srcdir}/.gdbinit ; then
5540   case ${srcdir} in
5541     .) ;;
5542     *) cat > ./.gdbinit <<EOF
5543 # ${NO_EDIT}
5544 dir ${srcdir}
5545 dir .
5546 source ${srcdir}/.gdbinit
5547 EOF
5548     ;;
5549   esac
5550 fi
5551
5552 # Make sure that the compiler is able to generate an executable.  If it
5553 # can't, we are probably in trouble.  We don't care whether we can run the
5554 # executable--we might be using a cross compiler--we only care whether it
5555 # can be created.  At this point the main configure script has set CC.
5556 we_are_ok=no
5557 echo "int main () { return 0; }" > conftest.c
5558 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5559 if test $? = 0 ; then
5560   if test -s conftest || test -s conftest.exe ; then
5561     we_are_ok=yes
5562   fi
5563 fi
5564 case $we_are_ok in
5565   no)
5566     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5567     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5568     rm -f conftest*
5569     exit 1
5570     ;;
5571 esac
5572 rm -f conftest*
5573
5574 # The Solaris /usr/ucb/cc compiler does not appear to work.
5575 case "${host}" in
5576   sparc-sun-solaris2*)
5577       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5578       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5579           could_use=
5580           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5581           if test -d /opt/cygnus/bin ; then
5582               if test "$could_use" = "" ; then
5583                   could_use="/opt/cygnus/bin"
5584               else
5585                   could_use="$could_use or /opt/cygnus/bin"
5586               fi
5587           fi
5588         if test "$could_use" = "" ; then
5589             echo "Warning: compilation may fail because you're using"
5590             echo "/usr/ucb/cc.  You should change your PATH or CC "
5591             echo "variable and rerun configure."
5592         else
5593             echo "Warning: compilation may fail because you're using"
5594             echo "/usr/ucb/cc, when you should use the C compiler from"
5595             echo "$could_use.  You should change your"
5596             echo "PATH or CC variable and rerun configure."
5597         fi
5598       fi
5599   ;;
5600 esac
5601
5602 # Decide which environment variable is used to find dynamic libraries.
5603 case "${host}" in
5604   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5605   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5606   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5607   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5608 esac
5609
5610 # On systems where the dynamic library environment variable is PATH,
5611 if test "$RPATH_ENVVAR" = PATH; then
5612   GCC_SHLIB_SUBDIR=/shlib
5613 else
5614   GCC_SHLIB_SUBDIR=
5615 fi
5616
5617 # Record target_configdirs and the configure arguments for target and
5618 # build configuration in Makefile.
5619 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5620 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5621
5622 # Determine whether gdb needs tk/tcl or not.
5623 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5624 # and in that case we want gdb to be built without tk.  Ugh!
5625 # In fact I believe gdb is the *only* package directly dependent on tk,
5626 # so we should be able to put the 'maybe's in unconditionally and
5627 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5628 # 100% sure that that's safe though.
5629
5630 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5631 case "$enable_gdbtk" in
5632   no)
5633     GDB_TK="" ;;
5634   yes)
5635     GDB_TK="${gdb_tk}" ;;
5636   *)
5637     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5638     # distro.  Eventually someone will fix this and move Insight, nee
5639     # gdbtk to a separate directory.
5640     if test -d ${srcdir}/gdb/gdbtk ; then
5641       GDB_TK="${gdb_tk}"
5642     else
5643       GDB_TK=""
5644     fi
5645     ;;
5646 esac
5647 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5648 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5649
5650 # Strip out unwanted targets.
5651
5652 # While at that, we remove Makefiles if we were started for recursive
5653 # configuration, so that the top-level Makefile reconfigures them,
5654 # like we used to do when configure itself was recursive.
5655
5656 # Loop over modules.  $extrasub must be used with care, limiting as
5657 # much as possible the usage of range addresses.  That's because autoconf
5658 # splits the sed script to overcome limits in the number of commands,
5659 # and relying on carefully-timed sed passes may turn out to be very hard
5660 # to maintain later.  In this particular case, you just have to be careful
5661 # not to nest @if/@endif pairs, because configure will not warn you at all.
5662
5663 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5664 if test "${enable_bootstrap+set}" = set; then
5665   enableval="$enable_bootstrap"
5666
5667 else
5668   enable_bootstrap=default
5669 fi;
5670
5671 # Issue errors and warnings for invalid/strange bootstrap combinations.
5672 case "$configdirs" in
5673   *gcc*) have_compiler=yes ;;
5674   *) have_compiler=no ;;
5675 esac
5676
5677 case "$have_compiler:$host:$target:$enable_bootstrap" in
5678   *:*:*:no) ;;
5679
5680   # Default behavior.  Enable bootstrap if we have a compiler
5681   # and we are in a native configuration.
5682   yes:$build:$build:default)
5683     enable_bootstrap=yes ;;
5684
5685   *:*:*:default)
5686     enable_bootstrap=no ;;
5687
5688   # We have a compiler and we are in a native configuration, bootstrap is ok
5689   yes:$build:$build:yes)
5690     ;;
5691
5692   # Other configurations, but we have a compiler.  Assume the user knows
5693   # what he's doing.
5694   yes:*:*:yes)
5695     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5696 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5697     ;;
5698
5699   # No compiler: if they passed --enable-bootstrap explicitly, fail
5700   no:*:*:yes)
5701     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5702 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5703    { (exit 1); exit 1; }; } ;;
5704
5705   # Fail if wrong command line
5706   *)
5707     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5708 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5709    { (exit 1); exit 1; }; }
5710     ;;
5711 esac
5712
5713 # Adjust the toplevel makefile according to whether bootstrap was selected.
5714 case "$enable_bootstrap" in
5715   yes)
5716     bootstrap_suffix=bootstrap ;;
5717   no)
5718     bootstrap_suffix=no-bootstrap ;;
5719 esac
5720
5721 for module in ${build_configdirs} ; do
5722   if test -z "${no_recursion}" \
5723      && test -f ${build_subdir}/${module}/Makefile; then
5724     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5725     rm -f ${build_subdir}/${module}/Makefile
5726   fi
5727   extrasub="$extrasub
5728 /^@if build-$module\$/d
5729 /^@endif build-$module\$/d
5730 /^@if build-$module-$bootstrap_suffix\$/d
5731 /^@endif build-$module-$bootstrap_suffix\$/d"
5732 done
5733 for module in ${configdirs} ; do
5734   if test -z "${no_recursion}"; then
5735     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5736       if test -f ${file}; then
5737         echo 1>&2 "*** removing ${file} to force reconfigure"
5738         rm -f ${file}
5739       fi
5740     done
5741   fi
5742   extrasub="$extrasub
5743 /^@if $module\$/d
5744 /^@endif $module\$/d
5745 /^@if $module-$bootstrap_suffix\$/d
5746 /^@endif $module-$bootstrap_suffix\$/d"
5747 done
5748 for module in ${target_configdirs} ; do
5749   if test -z "${no_recursion}" \
5750      && test -f ${target_subdir}/${module}/Makefile; then
5751     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5752     rm -f ${target_subdir}/${module}/Makefile
5753   fi
5754   extrasub="$extrasub
5755 /^@if target-$module\$/d
5756 /^@endif target-$module\$/d
5757 /^@if target-$module-$bootstrap_suffix\$/d
5758 /^@endif target-$module-$bootstrap_suffix\$/d"
5759 done
5760
5761 extrasub="$extrasub
5762 /^@if /,/^@endif /d"
5763
5764 # Create the serialization dependencies.  This uses a temporary file.
5765
5766 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5767 if test "${enable_serial_configure+set}" = set; then
5768   enableval="$enable_serial_configure"
5769
5770 fi;
5771
5772 case ${enable_serial_configure} in
5773   yes)
5774     enable_serial_build_configure=yes
5775     enable_serial_host_configure=yes
5776     enable_serial_target_configure=yes
5777     ;;
5778 esac
5779
5780 # These force 'configure's to be done one at a time, to avoid problems
5781 # with contention over a shared config.cache.
5782 rm -f serdep.tmp
5783 echo '# serdep.tmp' > serdep.tmp
5784 olditem=
5785 test "x${enable_serial_build_configure}" = xyes &&
5786 for item in ${build_configdirs} ; do
5787   case ${olditem} in
5788     "") ;;
5789     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5790   esac
5791   olditem=${item}
5792 done
5793 olditem=
5794 test "x${enable_serial_host_configure}" = xyes &&
5795 for item in ${configdirs} ; do
5796   case ${olditem} in
5797     "") ;;
5798     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5799   esac
5800   olditem=${item}
5801 done
5802 olditem=
5803 test "x${enable_serial_target_configure}" = xyes &&
5804 for item in ${target_configdirs} ; do
5805   case ${olditem} in
5806     "") ;;
5807     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5808   esac
5809   olditem=${item}
5810 done
5811 serialization_dependencies=serdep.tmp
5812
5813
5814 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5815 # target, nonopt, and variable assignments.  These are the ones we
5816 # might not want to pass down to subconfigures.  Also strip
5817 # program-prefix, program-suffix, and program-transform-name, so that
5818 # we can pass down a consistent program-transform-name.
5819 baseargs=
5820 keep_next=no
5821 skip_next=no
5822 eval "set -- $ac_configure_args"
5823 for ac_arg
5824 do
5825   if test X"$skip_next" = X"yes"; then
5826     skip_next=no
5827     continue
5828   fi
5829   if test X"$keep_next" = X"yes"; then
5830     case $ac_arg in
5831       *\'*)
5832         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5833     esac
5834     baseargs="$baseargs '$ac_arg'"
5835     keep_next=no
5836     continue
5837   fi
5838
5839   # Handle separated arguments.  Based on the logic generated by
5840   # autoconf 2.59.
5841   case $ac_arg in
5842     *=* | --config-cache | -C | -disable-* | --disable-* \
5843       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5844       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5845       | -with-* | --with-* | -without-* | --without-* | --x)
5846       separate_arg=no
5847       ;;
5848     -*)
5849       separate_arg=yes
5850       ;;
5851     *)
5852       separate_arg=no
5853       ;;
5854   esac
5855
5856   case "$ac_arg" in
5857     --no*)
5858       continue
5859       ;;
5860     --c* | \
5861     --sr* | \
5862     --ho* | \
5863     --bu* | \
5864     --t* | \
5865     --program-* | \
5866     -cache_file* | \
5867     -srcdir* | \
5868     -host* | \
5869     -build* | \
5870     -target* | \
5871     -program-prefix* | \
5872     -program-suffix* | \
5873     -program-transform-name* )
5874       skip_next=$separate_arg
5875       continue
5876       ;;
5877     -*)
5878       # An option.  Add it.
5879       case $ac_arg in
5880         *\'*)
5881           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5882       esac
5883       baseargs="$baseargs '$ac_arg'"
5884       keep_next=$separate_arg
5885       ;;
5886     *)
5887       # Either a variable assignment, or a nonopt (triplet).  Don't
5888       # pass it down; let the Makefile handle this.
5889       continue
5890       ;;
5891   esac
5892 done
5893 # Remove the initial space we just introduced and, as these will be
5894 # expanded by make, quote '$'.
5895 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5896
5897 # Add in --program-transform-name, after --program-prefix and
5898 # --program-suffix have been applied to it.  Autoconf has already
5899 # doubled dollar signs and backslashes in program_transform_name; we want
5900 # the backslashes un-doubled, and then the entire thing wrapped in single
5901 # quotes, because this will be expanded first by make and then by the shell.
5902 # Also, because we want to override the logic in subdir configure scripts to
5903 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5904 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5905 ${program_transform_name}
5906 EOF_SED
5907 gcc_transform_name=`cat conftestsed.out`
5908 rm -f conftestsed.out
5909 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5910 if test "$silent" = yes; then
5911   baseargs="$baseargs --silent"
5912 fi
5913
5914 # For the build-side libraries, we just need to pretend we're native,
5915 # and not use the same cache file.  Multilibs are neither needed nor
5916 # desired.
5917 build_configargs="--cache-file=../config.cache ${baseargs}"
5918
5919 # For host modules, accept cache file option, or specification as blank.
5920 case "${cache_file}" in
5921 "") # empty
5922   cache_file_option="" ;;
5923 /* | [A-Za-z]:[\\/]* ) # absolute path
5924   cache_file_option="--cache-file=${cache_file}" ;;
5925 *) # relative path
5926   cache_file_option="--cache-file=../${cache_file}" ;;
5927 esac
5928
5929 # Host dirs don't like to share a cache file either, horribly enough.
5930 # This seems to be due to autoconf 2.5x stupidity.
5931 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5932
5933 target_configargs=${baseargs}
5934
5935 # Passing a --with-cross-host argument lets the target libraries know
5936 # whether they are being built with a cross-compiler or being built
5937 # native.  However, it would be better to use other mechanisms to make the
5938 # sorts of decisions they want to make on this basis.  Please consider
5939 # this option to be deprecated.  FIXME.
5940 if test x${is_cross_compiler} = xyes ; then
5941   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5942 fi
5943
5944 # Default to --enable-multilib.
5945 if test x${enable_multilib} = x ; then
5946   target_configargs="--enable-multilib ${target_configargs}"
5947 fi
5948
5949 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5950 # changed from the earlier setting of with_newlib.
5951 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5952   target_configargs="--with-newlib ${target_configargs}"
5953 fi
5954
5955 # Different target subdirs use different values of certain variables
5956 # (notably CXX).  Worse, multilibs use *lots* of different values.
5957 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5958 # it doesn't automatically accept command-line overrides of them.
5959 # This means it's not safe for target subdirs to share a cache file,
5960 # which is disgusting, but there you have it.  Hopefully this can be
5961 # fixed in future.  It's still worthwhile to use a cache file for each
5962 # directory.  I think.
5963
5964 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5965 # We need to pass --target, as newer autoconf's requires consistency
5966 # for target_alias and gcc doesn't manage it consistently.
5967 target_configargs="--cache-file=./config.cache ${target_configargs}"
5968
5969 FLAGS_FOR_TARGET=
5970 case " $target_configdirs " in
5971  *" newlib "*)
5972   case " $target_configargs " in
5973   *" --with-newlib "*)
5974    case "$target" in
5975    *-cygwin*)
5976      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' ;;
5977    esac
5978
5979    # If we're not building GCC, don't discard standard headers.
5980    if test -d ${srcdir}/gcc; then
5981      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5982
5983      if test "${build}" != "${host}"; then
5984        # On Canadian crosses, CC_FOR_TARGET will have already been set
5985        # by `configure', so we won't have an opportunity to add -Bgcc/
5986        # to it.  This is right: we don't want to search that directory
5987        # for binaries, but we want the header files in there, so add
5988        # them explicitly.
5989        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5990
5991        # Someone might think of using the pre-installed headers on
5992        # Canadian crosses, in case the installed compiler is not fully
5993        # compatible with the compiler being built.  In this case, it
5994        # would be better to flag an error than risking having
5995        # incompatible object files being constructed.  We can't
5996        # guarantee that an error will be flagged, but let's hope the
5997        # compiler will do it, when presented with incompatible header
5998        # files.
5999      fi
6000    fi
6001
6002    case "${target}-${is_cross_compiler}" in
6003    i[3456789]86-*-linux*-no)
6004       # Here host == target, so we don't need to build gcc,
6005       # so we don't want to discard standard headers.
6006       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6007       ;;
6008    *)
6009       # If we're building newlib, use its generic headers last, but search
6010       # for any libc-related directories first (so make it the last -B
6011       # switch).
6012       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6013
6014       # If we're building libgloss, find the startup file, simulator library
6015       # and linker script.
6016       case " $target_configdirs " in
6017         *" libgloss "*)
6018         # Look for startup file, simulator library and maybe linker script.
6019         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6020         # Look for libnosys.a in case the target needs it.
6021         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6022         # Most targets have the linker script in the source directory.
6023         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6024         ;;
6025       esac
6026       ;;
6027    esac
6028    ;;
6029   esac
6030   ;;
6031 esac
6032 case "$target" in
6033 *-mingw*)
6034   # Can't be handled as Cygwin above since Mingw does not use newlib.
6035   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' ;;
6036 esac
6037
6038 # Allow the user to override the flags for
6039 # our build compiler if desired.
6040 if test x"${build}" = x"${host}" ; then
6041   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6042   CPPFLAGS_FOR_BUILD=${CPPFLAGS_FOR_BUILD-${CPPFLAGS}}
6043   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6044   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6045 fi
6046
6047 # On Canadian crosses, we'll be searching the right directories for
6048 # the previously-installed cross compiler, so don't bother to add
6049 # flags for directories within the install tree of the compiler
6050 # being built; programs in there won't even run.
6051 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6052   # Search for pre-installed headers if nothing else fits.
6053   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6054 fi
6055
6056 if test "x${use_gnu_ld}" = x &&
6057    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6058   # Arrange for us to find uninstalled linker scripts.
6059   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6060 fi
6061
6062 # Search for other target-specific linker scripts and such.
6063 case "${target}" in
6064   mep*)
6065     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6066     ;;
6067 esac
6068
6069 # Makefile fragments.
6070 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6071 do
6072   eval fragval=\$$frag
6073   if test $fragval != /dev/null; then
6074     eval $frag=${srcdir}/$fragval
6075   fi
6076 done
6077
6078
6079
6080
6081
6082 # Miscellanea: directories, flags, etc.
6083
6084
6085
6086
6087
6088
6089
6090
6091 # Build module lists & subconfigure args.
6092
6093
6094
6095 # Host module lists & subconfigure args.
6096
6097
6098
6099 # Target module lists & subconfigure args.
6100
6101
6102
6103 # Build tools.
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121
6122 # Generate default definitions for YACC, M4, LEX and other programs that run
6123 # on the build machine.  These are used if the Makefile can't locate these
6124 # programs in objdir.
6125 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6126
6127 for ac_prog in 'bison -y' byacc yacc
6128 do
6129   # Extract the first word of "$ac_prog", so it can be a program name with args.
6130 set dummy $ac_prog; ac_word=$2
6131 echo "$as_me:$LINENO: checking for $ac_word" >&5
6132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6133 if test "${ac_cv_prog_YACC+set}" = set; then
6134   echo $ECHO_N "(cached) $ECHO_C" >&6
6135 else
6136   if test -n "$YACC"; then
6137   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6138 else
6139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6140 for as_dir in $PATH
6141 do
6142   IFS=$as_save_IFS
6143   test -z "$as_dir" && as_dir=.
6144   for ac_exec_ext in '' $ac_executable_extensions; do
6145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6146     ac_cv_prog_YACC="$ac_prog"
6147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6148     break 2
6149   fi
6150 done
6151 done
6152
6153 fi
6154 fi
6155 YACC=$ac_cv_prog_YACC
6156 if test -n "$YACC"; then
6157   echo "$as_me:$LINENO: result: $YACC" >&5
6158 echo "${ECHO_T}$YACC" >&6
6159 else
6160   echo "$as_me:$LINENO: result: no" >&5
6161 echo "${ECHO_T}no" >&6
6162 fi
6163
6164   test -n "$YACC" && break
6165 done
6166 test -n "$YACC" || YACC="$MISSING bison -y"
6167
6168 case " $build_configdirs " in
6169   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6170   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6171 esac
6172
6173 for ac_prog in bison
6174 do
6175   # Extract the first word of "$ac_prog", so it can be a program name with args.
6176 set dummy $ac_prog; ac_word=$2
6177 echo "$as_me:$LINENO: checking for $ac_word" >&5
6178 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6179 if test "${ac_cv_prog_BISON+set}" = set; then
6180   echo $ECHO_N "(cached) $ECHO_C" >&6
6181 else
6182   if test -n "$BISON"; then
6183   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6184 else
6185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6186 for as_dir in $PATH
6187 do
6188   IFS=$as_save_IFS
6189   test -z "$as_dir" && as_dir=.
6190   for ac_exec_ext in '' $ac_executable_extensions; do
6191   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6192     ac_cv_prog_BISON="$ac_prog"
6193     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6194     break 2
6195   fi
6196 done
6197 done
6198
6199 fi
6200 fi
6201 BISON=$ac_cv_prog_BISON
6202 if test -n "$BISON"; then
6203   echo "$as_me:$LINENO: result: $BISON" >&5
6204 echo "${ECHO_T}$BISON" >&6
6205 else
6206   echo "$as_me:$LINENO: result: no" >&5
6207 echo "${ECHO_T}no" >&6
6208 fi
6209
6210   test -n "$BISON" && break
6211 done
6212 test -n "$BISON" || BISON="$MISSING bison"
6213
6214 case " $build_configdirs " in
6215   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6216 esac
6217
6218 for ac_prog in gm4 gnum4 m4
6219 do
6220   # Extract the first word of "$ac_prog", so it can be a program name with args.
6221 set dummy $ac_prog; ac_word=$2
6222 echo "$as_me:$LINENO: checking for $ac_word" >&5
6223 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6224 if test "${ac_cv_prog_M4+set}" = set; then
6225   echo $ECHO_N "(cached) $ECHO_C" >&6
6226 else
6227   if test -n "$M4"; then
6228   ac_cv_prog_M4="$M4" # Let the user override the test.
6229 else
6230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6231 for as_dir in $PATH
6232 do
6233   IFS=$as_save_IFS
6234   test -z "$as_dir" && as_dir=.
6235   for ac_exec_ext in '' $ac_executable_extensions; do
6236   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6237     ac_cv_prog_M4="$ac_prog"
6238     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6239     break 2
6240   fi
6241 done
6242 done
6243
6244 fi
6245 fi
6246 M4=$ac_cv_prog_M4
6247 if test -n "$M4"; then
6248   echo "$as_me:$LINENO: result: $M4" >&5
6249 echo "${ECHO_T}$M4" >&6
6250 else
6251   echo "$as_me:$LINENO: result: no" >&5
6252 echo "${ECHO_T}no" >&6
6253 fi
6254
6255   test -n "$M4" && break
6256 done
6257 test -n "$M4" || M4="$MISSING m4"
6258
6259 case " $build_configdirs " in
6260   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6261 esac
6262
6263 for ac_prog in flex lex
6264 do
6265   # Extract the first word of "$ac_prog", so it can be a program name with args.
6266 set dummy $ac_prog; ac_word=$2
6267 echo "$as_me:$LINENO: checking for $ac_word" >&5
6268 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6269 if test "${ac_cv_prog_LEX+set}" = set; then
6270   echo $ECHO_N "(cached) $ECHO_C" >&6
6271 else
6272   if test -n "$LEX"; then
6273   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6274 else
6275 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6276 for as_dir in $PATH
6277 do
6278   IFS=$as_save_IFS
6279   test -z "$as_dir" && as_dir=.
6280   for ac_exec_ext in '' $ac_executable_extensions; do
6281   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6282     ac_cv_prog_LEX="$ac_prog"
6283     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6284     break 2
6285   fi
6286 done
6287 done
6288
6289 fi
6290 fi
6291 LEX=$ac_cv_prog_LEX
6292 if test -n "$LEX"; then
6293   echo "$as_me:$LINENO: result: $LEX" >&5
6294 echo "${ECHO_T}$LEX" >&6
6295 else
6296   echo "$as_me:$LINENO: result: no" >&5
6297 echo "${ECHO_T}no" >&6
6298 fi
6299
6300   test -n "$LEX" && break
6301 done
6302 test -n "$LEX" || LEX="$MISSING flex"
6303
6304 case " $build_configdirs " in
6305   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6306   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6307 esac
6308
6309 for ac_prog in flex
6310 do
6311   # Extract the first word of "$ac_prog", so it can be a program name with args.
6312 set dummy $ac_prog; ac_word=$2
6313 echo "$as_me:$LINENO: checking for $ac_word" >&5
6314 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6315 if test "${ac_cv_prog_FLEX+set}" = set; then
6316   echo $ECHO_N "(cached) $ECHO_C" >&6
6317 else
6318   if test -n "$FLEX"; then
6319   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6320 else
6321 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6322 for as_dir in $PATH
6323 do
6324   IFS=$as_save_IFS
6325   test -z "$as_dir" && as_dir=.
6326   for ac_exec_ext in '' $ac_executable_extensions; do
6327   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6328     ac_cv_prog_FLEX="$ac_prog"
6329     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6330     break 2
6331   fi
6332 done
6333 done
6334
6335 fi
6336 fi
6337 FLEX=$ac_cv_prog_FLEX
6338 if test -n "$FLEX"; then
6339   echo "$as_me:$LINENO: result: $FLEX" >&5
6340 echo "${ECHO_T}$FLEX" >&6
6341 else
6342   echo "$as_me:$LINENO: result: no" >&5
6343 echo "${ECHO_T}no" >&6
6344 fi
6345
6346   test -n "$FLEX" && break
6347 done
6348 test -n "$FLEX" || FLEX="$MISSING flex"
6349
6350 case " $build_configdirs " in
6351   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6352 esac
6353
6354 for ac_prog in makeinfo
6355 do
6356   # Extract the first word of "$ac_prog", so it can be a program name with args.
6357 set dummy $ac_prog; ac_word=$2
6358 echo "$as_me:$LINENO: checking for $ac_word" >&5
6359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6360 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6361   echo $ECHO_N "(cached) $ECHO_C" >&6
6362 else
6363   if test -n "$MAKEINFO"; then
6364   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6365 else
6366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6367 for as_dir in $PATH
6368 do
6369   IFS=$as_save_IFS
6370   test -z "$as_dir" && as_dir=.
6371   for ac_exec_ext in '' $ac_executable_extensions; do
6372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6373     ac_cv_prog_MAKEINFO="$ac_prog"
6374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6375     break 2
6376   fi
6377 done
6378 done
6379
6380 fi
6381 fi
6382 MAKEINFO=$ac_cv_prog_MAKEINFO
6383 if test -n "$MAKEINFO"; then
6384   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6385 echo "${ECHO_T}$MAKEINFO" >&6
6386 else
6387   echo "$as_me:$LINENO: result: no" >&5
6388 echo "${ECHO_T}no" >&6
6389 fi
6390
6391   test -n "$MAKEINFO" && break
6392 done
6393 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6394
6395 case " $build_configdirs " in
6396   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6397   *)
6398
6399     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6400     # higher, else we use the "missing" dummy.
6401     if ${MAKEINFO} --version \
6402        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6403       :
6404     else
6405       MAKEINFO="$MISSING makeinfo"
6406     fi
6407     ;;
6408
6409 esac
6410
6411 # FIXME: expect and dejagnu may become build tools?
6412
6413 for ac_prog in expect
6414 do
6415   # Extract the first word of "$ac_prog", so it can be a program name with args.
6416 set dummy $ac_prog; ac_word=$2
6417 echo "$as_me:$LINENO: checking for $ac_word" >&5
6418 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6419 if test "${ac_cv_prog_EXPECT+set}" = set; then
6420   echo $ECHO_N "(cached) $ECHO_C" >&6
6421 else
6422   if test -n "$EXPECT"; then
6423   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6424 else
6425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6426 for as_dir in $PATH
6427 do
6428   IFS=$as_save_IFS
6429   test -z "$as_dir" && as_dir=.
6430   for ac_exec_ext in '' $ac_executable_extensions; do
6431   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6432     ac_cv_prog_EXPECT="$ac_prog"
6433     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6434     break 2
6435   fi
6436 done
6437 done
6438
6439 fi
6440 fi
6441 EXPECT=$ac_cv_prog_EXPECT
6442 if test -n "$EXPECT"; then
6443   echo "$as_me:$LINENO: result: $EXPECT" >&5
6444 echo "${ECHO_T}$EXPECT" >&6
6445 else
6446   echo "$as_me:$LINENO: result: no" >&5
6447 echo "${ECHO_T}no" >&6
6448 fi
6449
6450   test -n "$EXPECT" && break
6451 done
6452 test -n "$EXPECT" || EXPECT="expect"
6453
6454 case " $configdirs " in
6455   *" expect "*)
6456     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6457     ;;
6458 esac
6459
6460 for ac_prog in runtest
6461 do
6462   # Extract the first word of "$ac_prog", so it can be a program name with args.
6463 set dummy $ac_prog; ac_word=$2
6464 echo "$as_me:$LINENO: checking for $ac_word" >&5
6465 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6466 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6467   echo $ECHO_N "(cached) $ECHO_C" >&6
6468 else
6469   if test -n "$RUNTEST"; then
6470   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6471 else
6472 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6473 for as_dir in $PATH
6474 do
6475   IFS=$as_save_IFS
6476   test -z "$as_dir" && as_dir=.
6477   for ac_exec_ext in '' $ac_executable_extensions; do
6478   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6479     ac_cv_prog_RUNTEST="$ac_prog"
6480     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6481     break 2
6482   fi
6483 done
6484 done
6485
6486 fi
6487 fi
6488 RUNTEST=$ac_cv_prog_RUNTEST
6489 if test -n "$RUNTEST"; then
6490   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6491 echo "${ECHO_T}$RUNTEST" >&6
6492 else
6493   echo "$as_me:$LINENO: result: no" >&5
6494 echo "${ECHO_T}no" >&6
6495 fi
6496
6497   test -n "$RUNTEST" && break
6498 done
6499 test -n "$RUNTEST" || RUNTEST="runtest"
6500
6501 case " $configdirs " in
6502   *" dejagnu "*)
6503     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6504     ;;
6505 esac
6506
6507
6508 # Host tools.
6509 ncn_tool_prefix=
6510 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6511 ncn_target_tool_prefix=
6512 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6513
6514
6515
6516 if test -n "$AR"; then
6517   ac_cv_prog_AR=$AR
6518 elif test -n "$ac_cv_prog_AR"; then
6519   AR=$ac_cv_prog_AR
6520 fi
6521
6522 if test -n "$ac_cv_prog_AR"; then
6523   for ncn_progname in ar; do
6524     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6525 set dummy ${ncn_progname}; ac_word=$2
6526 echo "$as_me:$LINENO: checking for $ac_word" >&5
6527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6528 if test "${ac_cv_prog_AR+set}" = set; then
6529   echo $ECHO_N "(cached) $ECHO_C" >&6
6530 else
6531   if test -n "$AR"; then
6532   ac_cv_prog_AR="$AR" # Let the user override the test.
6533 else
6534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6535 for as_dir in $PATH
6536 do
6537   IFS=$as_save_IFS
6538   test -z "$as_dir" && as_dir=.
6539   for ac_exec_ext in '' $ac_executable_extensions; do
6540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6541     ac_cv_prog_AR="${ncn_progname}"
6542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6543     break 2
6544   fi
6545 done
6546 done
6547
6548 fi
6549 fi
6550 AR=$ac_cv_prog_AR
6551 if test -n "$AR"; then
6552   echo "$as_me:$LINENO: result: $AR" >&5
6553 echo "${ECHO_T}$AR" >&6
6554 else
6555   echo "$as_me:$LINENO: result: no" >&5
6556 echo "${ECHO_T}no" >&6
6557 fi
6558
6559   done
6560 fi
6561
6562 for ncn_progname in ar; do
6563   if test -n "$ncn_tool_prefix"; then
6564     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6565 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6566 echo "$as_me:$LINENO: checking for $ac_word" >&5
6567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6568 if test "${ac_cv_prog_AR+set}" = set; then
6569   echo $ECHO_N "(cached) $ECHO_C" >&6
6570 else
6571   if test -n "$AR"; then
6572   ac_cv_prog_AR="$AR" # Let the user override the test.
6573 else
6574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6575 for as_dir in $PATH
6576 do
6577   IFS=$as_save_IFS
6578   test -z "$as_dir" && as_dir=.
6579   for ac_exec_ext in '' $ac_executable_extensions; do
6580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6581     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6583     break 2
6584   fi
6585 done
6586 done
6587
6588 fi
6589 fi
6590 AR=$ac_cv_prog_AR
6591 if test -n "$AR"; then
6592   echo "$as_me:$LINENO: result: $AR" >&5
6593 echo "${ECHO_T}$AR" >&6
6594 else
6595   echo "$as_me:$LINENO: result: no" >&5
6596 echo "${ECHO_T}no" >&6
6597 fi
6598
6599   fi
6600   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6601     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6602 set dummy ${ncn_progname}; ac_word=$2
6603 echo "$as_me:$LINENO: checking for $ac_word" >&5
6604 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6605 if test "${ac_cv_prog_AR+set}" = set; then
6606   echo $ECHO_N "(cached) $ECHO_C" >&6
6607 else
6608   if test -n "$AR"; then
6609   ac_cv_prog_AR="$AR" # Let the user override the test.
6610 else
6611 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6612 for as_dir in $PATH
6613 do
6614   IFS=$as_save_IFS
6615   test -z "$as_dir" && as_dir=.
6616   for ac_exec_ext in '' $ac_executable_extensions; do
6617   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6618     ac_cv_prog_AR="${ncn_progname}"
6619     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6620     break 2
6621   fi
6622 done
6623 done
6624
6625 fi
6626 fi
6627 AR=$ac_cv_prog_AR
6628 if test -n "$AR"; then
6629   echo "$as_me:$LINENO: result: $AR" >&5
6630 echo "${ECHO_T}$AR" >&6
6631 else
6632   echo "$as_me:$LINENO: result: no" >&5
6633 echo "${ECHO_T}no" >&6
6634 fi
6635
6636   fi
6637   test -n "$ac_cv_prog_AR" && break
6638 done
6639
6640 if test -z "$ac_cv_prog_AR" ; then
6641   set dummy ar
6642   if test $build = $host ; then
6643     AR="$2"
6644   else
6645     AR="${ncn_tool_prefix}$2"
6646   fi
6647 fi
6648
6649
6650
6651 if test -n "$AS"; then
6652   ac_cv_prog_AS=$AS
6653 elif test -n "$ac_cv_prog_AS"; then
6654   AS=$ac_cv_prog_AS
6655 fi
6656
6657 if test -n "$ac_cv_prog_AS"; then
6658   for ncn_progname in as; do
6659     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6660 set dummy ${ncn_progname}; ac_word=$2
6661 echo "$as_me:$LINENO: checking for $ac_word" >&5
6662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6663 if test "${ac_cv_prog_AS+set}" = set; then
6664   echo $ECHO_N "(cached) $ECHO_C" >&6
6665 else
6666   if test -n "$AS"; then
6667   ac_cv_prog_AS="$AS" # Let the user override the test.
6668 else
6669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6670 for as_dir in $PATH
6671 do
6672   IFS=$as_save_IFS
6673   test -z "$as_dir" && as_dir=.
6674   for ac_exec_ext in '' $ac_executable_extensions; do
6675   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6676     ac_cv_prog_AS="${ncn_progname}"
6677     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6678     break 2
6679   fi
6680 done
6681 done
6682
6683 fi
6684 fi
6685 AS=$ac_cv_prog_AS
6686 if test -n "$AS"; then
6687   echo "$as_me:$LINENO: result: $AS" >&5
6688 echo "${ECHO_T}$AS" >&6
6689 else
6690   echo "$as_me:$LINENO: result: no" >&5
6691 echo "${ECHO_T}no" >&6
6692 fi
6693
6694   done
6695 fi
6696
6697 for ncn_progname in as; do
6698   if test -n "$ncn_tool_prefix"; then
6699     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6700 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6701 echo "$as_me:$LINENO: checking for $ac_word" >&5
6702 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6703 if test "${ac_cv_prog_AS+set}" = set; then
6704   echo $ECHO_N "(cached) $ECHO_C" >&6
6705 else
6706   if test -n "$AS"; then
6707   ac_cv_prog_AS="$AS" # Let the user override the test.
6708 else
6709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6710 for as_dir in $PATH
6711 do
6712   IFS=$as_save_IFS
6713   test -z "$as_dir" && as_dir=.
6714   for ac_exec_ext in '' $ac_executable_extensions; do
6715   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6716     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6717     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6718     break 2
6719   fi
6720 done
6721 done
6722
6723 fi
6724 fi
6725 AS=$ac_cv_prog_AS
6726 if test -n "$AS"; then
6727   echo "$as_me:$LINENO: result: $AS" >&5
6728 echo "${ECHO_T}$AS" >&6
6729 else
6730   echo "$as_me:$LINENO: result: no" >&5
6731 echo "${ECHO_T}no" >&6
6732 fi
6733
6734   fi
6735   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6736     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6737 set dummy ${ncn_progname}; ac_word=$2
6738 echo "$as_me:$LINENO: checking for $ac_word" >&5
6739 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6740 if test "${ac_cv_prog_AS+set}" = set; then
6741   echo $ECHO_N "(cached) $ECHO_C" >&6
6742 else
6743   if test -n "$AS"; then
6744   ac_cv_prog_AS="$AS" # Let the user override the test.
6745 else
6746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6747 for as_dir in $PATH
6748 do
6749   IFS=$as_save_IFS
6750   test -z "$as_dir" && as_dir=.
6751   for ac_exec_ext in '' $ac_executable_extensions; do
6752   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6753     ac_cv_prog_AS="${ncn_progname}"
6754     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6755     break 2
6756   fi
6757 done
6758 done
6759
6760 fi
6761 fi
6762 AS=$ac_cv_prog_AS
6763 if test -n "$AS"; then
6764   echo "$as_me:$LINENO: result: $AS" >&5
6765 echo "${ECHO_T}$AS" >&6
6766 else
6767   echo "$as_me:$LINENO: result: no" >&5
6768 echo "${ECHO_T}no" >&6
6769 fi
6770
6771   fi
6772   test -n "$ac_cv_prog_AS" && break
6773 done
6774
6775 if test -z "$ac_cv_prog_AS" ; then
6776   set dummy as
6777   if test $build = $host ; then
6778     AS="$2"
6779   else
6780     AS="${ncn_tool_prefix}$2"
6781   fi
6782 fi
6783
6784
6785
6786 if test -n "$DLLTOOL"; then
6787   ac_cv_prog_DLLTOOL=$DLLTOOL
6788 elif test -n "$ac_cv_prog_DLLTOOL"; then
6789   DLLTOOL=$ac_cv_prog_DLLTOOL
6790 fi
6791
6792 if test -n "$ac_cv_prog_DLLTOOL"; then
6793   for ncn_progname in dlltool; do
6794     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6795 set dummy ${ncn_progname}; ac_word=$2
6796 echo "$as_me:$LINENO: checking for $ac_word" >&5
6797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6798 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6799   echo $ECHO_N "(cached) $ECHO_C" >&6
6800 else
6801   if test -n "$DLLTOOL"; then
6802   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6803 else
6804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6805 for as_dir in $PATH
6806 do
6807   IFS=$as_save_IFS
6808   test -z "$as_dir" && as_dir=.
6809   for ac_exec_ext in '' $ac_executable_extensions; do
6810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6811     ac_cv_prog_DLLTOOL="${ncn_progname}"
6812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6813     break 2
6814   fi
6815 done
6816 done
6817
6818 fi
6819 fi
6820 DLLTOOL=$ac_cv_prog_DLLTOOL
6821 if test -n "$DLLTOOL"; then
6822   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6823 echo "${ECHO_T}$DLLTOOL" >&6
6824 else
6825   echo "$as_me:$LINENO: result: no" >&5
6826 echo "${ECHO_T}no" >&6
6827 fi
6828
6829   done
6830 fi
6831
6832 for ncn_progname in dlltool; do
6833   if test -n "$ncn_tool_prefix"; then
6834     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6835 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6836 echo "$as_me:$LINENO: checking for $ac_word" >&5
6837 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6838 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6839   echo $ECHO_N "(cached) $ECHO_C" >&6
6840 else
6841   if test -n "$DLLTOOL"; then
6842   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6843 else
6844 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6845 for as_dir in $PATH
6846 do
6847   IFS=$as_save_IFS
6848   test -z "$as_dir" && as_dir=.
6849   for ac_exec_ext in '' $ac_executable_extensions; do
6850   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6851     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6852     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6853     break 2
6854   fi
6855 done
6856 done
6857
6858 fi
6859 fi
6860 DLLTOOL=$ac_cv_prog_DLLTOOL
6861 if test -n "$DLLTOOL"; then
6862   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6863 echo "${ECHO_T}$DLLTOOL" >&6
6864 else
6865   echo "$as_me:$LINENO: result: no" >&5
6866 echo "${ECHO_T}no" >&6
6867 fi
6868
6869   fi
6870   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6871     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6872 set dummy ${ncn_progname}; ac_word=$2
6873 echo "$as_me:$LINENO: checking for $ac_word" >&5
6874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6875 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6876   echo $ECHO_N "(cached) $ECHO_C" >&6
6877 else
6878   if test -n "$DLLTOOL"; then
6879   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6880 else
6881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6882 for as_dir in $PATH
6883 do
6884   IFS=$as_save_IFS
6885   test -z "$as_dir" && as_dir=.
6886   for ac_exec_ext in '' $ac_executable_extensions; do
6887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6888     ac_cv_prog_DLLTOOL="${ncn_progname}"
6889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6890     break 2
6891   fi
6892 done
6893 done
6894
6895 fi
6896 fi
6897 DLLTOOL=$ac_cv_prog_DLLTOOL
6898 if test -n "$DLLTOOL"; then
6899   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6900 echo "${ECHO_T}$DLLTOOL" >&6
6901 else
6902   echo "$as_me:$LINENO: result: no" >&5
6903 echo "${ECHO_T}no" >&6
6904 fi
6905
6906   fi
6907   test -n "$ac_cv_prog_DLLTOOL" && break
6908 done
6909
6910 if test -z "$ac_cv_prog_DLLTOOL" ; then
6911   set dummy dlltool
6912   if test $build = $host ; then
6913     DLLTOOL="$2"
6914   else
6915     DLLTOOL="${ncn_tool_prefix}$2"
6916   fi
6917 fi
6918
6919
6920
6921 if test -n "$LD"; then
6922   ac_cv_prog_LD=$LD
6923 elif test -n "$ac_cv_prog_LD"; then
6924   LD=$ac_cv_prog_LD
6925 fi
6926
6927 if test -n "$ac_cv_prog_LD"; then
6928   for ncn_progname in ld; do
6929     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6930 set dummy ${ncn_progname}; ac_word=$2
6931 echo "$as_me:$LINENO: checking for $ac_word" >&5
6932 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6933 if test "${ac_cv_prog_LD+set}" = set; then
6934   echo $ECHO_N "(cached) $ECHO_C" >&6
6935 else
6936   if test -n "$LD"; then
6937   ac_cv_prog_LD="$LD" # Let the user override the test.
6938 else
6939 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6940 for as_dir in $PATH
6941 do
6942   IFS=$as_save_IFS
6943   test -z "$as_dir" && as_dir=.
6944   for ac_exec_ext in '' $ac_executable_extensions; do
6945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6946     ac_cv_prog_LD="${ncn_progname}"
6947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6948     break 2
6949   fi
6950 done
6951 done
6952
6953 fi
6954 fi
6955 LD=$ac_cv_prog_LD
6956 if test -n "$LD"; then
6957   echo "$as_me:$LINENO: result: $LD" >&5
6958 echo "${ECHO_T}$LD" >&6
6959 else
6960   echo "$as_me:$LINENO: result: no" >&5
6961 echo "${ECHO_T}no" >&6
6962 fi
6963
6964   done
6965 fi
6966
6967 for ncn_progname in ld; do
6968   if test -n "$ncn_tool_prefix"; then
6969     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6970 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6971 echo "$as_me:$LINENO: checking for $ac_word" >&5
6972 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6973 if test "${ac_cv_prog_LD+set}" = set; then
6974   echo $ECHO_N "(cached) $ECHO_C" >&6
6975 else
6976   if test -n "$LD"; then
6977   ac_cv_prog_LD="$LD" # Let the user override the test.
6978 else
6979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6980 for as_dir in $PATH
6981 do
6982   IFS=$as_save_IFS
6983   test -z "$as_dir" && as_dir=.
6984   for ac_exec_ext in '' $ac_executable_extensions; do
6985   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6986     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6987     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6988     break 2
6989   fi
6990 done
6991 done
6992
6993 fi
6994 fi
6995 LD=$ac_cv_prog_LD
6996 if test -n "$LD"; then
6997   echo "$as_me:$LINENO: result: $LD" >&5
6998 echo "${ECHO_T}$LD" >&6
6999 else
7000   echo "$as_me:$LINENO: result: no" >&5
7001 echo "${ECHO_T}no" >&6
7002 fi
7003
7004   fi
7005   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7006     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7007 set dummy ${ncn_progname}; ac_word=$2
7008 echo "$as_me:$LINENO: checking for $ac_word" >&5
7009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7010 if test "${ac_cv_prog_LD+set}" = set; then
7011   echo $ECHO_N "(cached) $ECHO_C" >&6
7012 else
7013   if test -n "$LD"; then
7014   ac_cv_prog_LD="$LD" # Let the user override the test.
7015 else
7016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7017 for as_dir in $PATH
7018 do
7019   IFS=$as_save_IFS
7020   test -z "$as_dir" && as_dir=.
7021   for ac_exec_ext in '' $ac_executable_extensions; do
7022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7023     ac_cv_prog_LD="${ncn_progname}"
7024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7025     break 2
7026   fi
7027 done
7028 done
7029
7030 fi
7031 fi
7032 LD=$ac_cv_prog_LD
7033 if test -n "$LD"; then
7034   echo "$as_me:$LINENO: result: $LD" >&5
7035 echo "${ECHO_T}$LD" >&6
7036 else
7037   echo "$as_me:$LINENO: result: no" >&5
7038 echo "${ECHO_T}no" >&6
7039 fi
7040
7041   fi
7042   test -n "$ac_cv_prog_LD" && break
7043 done
7044
7045 if test -z "$ac_cv_prog_LD" ; then
7046   set dummy ld
7047   if test $build = $host ; then
7048     LD="$2"
7049   else
7050     LD="${ncn_tool_prefix}$2"
7051   fi
7052 fi
7053
7054
7055
7056 if test -n "$LIPO"; then
7057   ac_cv_prog_LIPO=$LIPO
7058 elif test -n "$ac_cv_prog_LIPO"; then
7059   LIPO=$ac_cv_prog_LIPO
7060 fi
7061
7062 if test -n "$ac_cv_prog_LIPO"; then
7063   for ncn_progname in lipo; do
7064     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7065 set dummy ${ncn_progname}; ac_word=$2
7066 echo "$as_me:$LINENO: checking for $ac_word" >&5
7067 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7068 if test "${ac_cv_prog_LIPO+set}" = set; then
7069   echo $ECHO_N "(cached) $ECHO_C" >&6
7070 else
7071   if test -n "$LIPO"; then
7072   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7073 else
7074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7075 for as_dir in $PATH
7076 do
7077   IFS=$as_save_IFS
7078   test -z "$as_dir" && as_dir=.
7079   for ac_exec_ext in '' $ac_executable_extensions; do
7080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7081     ac_cv_prog_LIPO="${ncn_progname}"
7082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7083     break 2
7084   fi
7085 done
7086 done
7087
7088 fi
7089 fi
7090 LIPO=$ac_cv_prog_LIPO
7091 if test -n "$LIPO"; then
7092   echo "$as_me:$LINENO: result: $LIPO" >&5
7093 echo "${ECHO_T}$LIPO" >&6
7094 else
7095   echo "$as_me:$LINENO: result: no" >&5
7096 echo "${ECHO_T}no" >&6
7097 fi
7098
7099   done
7100 fi
7101
7102 for ncn_progname in lipo; do
7103   if test -n "$ncn_tool_prefix"; then
7104     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7105 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7106 echo "$as_me:$LINENO: checking for $ac_word" >&5
7107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7108 if test "${ac_cv_prog_LIPO+set}" = set; then
7109   echo $ECHO_N "(cached) $ECHO_C" >&6
7110 else
7111   if test -n "$LIPO"; then
7112   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7113 else
7114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7115 for as_dir in $PATH
7116 do
7117   IFS=$as_save_IFS
7118   test -z "$as_dir" && as_dir=.
7119   for ac_exec_ext in '' $ac_executable_extensions; do
7120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7121     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7123     break 2
7124   fi
7125 done
7126 done
7127
7128 fi
7129 fi
7130 LIPO=$ac_cv_prog_LIPO
7131 if test -n "$LIPO"; then
7132   echo "$as_me:$LINENO: result: $LIPO" >&5
7133 echo "${ECHO_T}$LIPO" >&6
7134 else
7135   echo "$as_me:$LINENO: result: no" >&5
7136 echo "${ECHO_T}no" >&6
7137 fi
7138
7139   fi
7140   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7141     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7142 set dummy ${ncn_progname}; ac_word=$2
7143 echo "$as_me:$LINENO: checking for $ac_word" >&5
7144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7145 if test "${ac_cv_prog_LIPO+set}" = set; then
7146   echo $ECHO_N "(cached) $ECHO_C" >&6
7147 else
7148   if test -n "$LIPO"; then
7149   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7150 else
7151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7152 for as_dir in $PATH
7153 do
7154   IFS=$as_save_IFS
7155   test -z "$as_dir" && as_dir=.
7156   for ac_exec_ext in '' $ac_executable_extensions; do
7157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7158     ac_cv_prog_LIPO="${ncn_progname}"
7159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7160     break 2
7161   fi
7162 done
7163 done
7164
7165 fi
7166 fi
7167 LIPO=$ac_cv_prog_LIPO
7168 if test -n "$LIPO"; then
7169   echo "$as_me:$LINENO: result: $LIPO" >&5
7170 echo "${ECHO_T}$LIPO" >&6
7171 else
7172   echo "$as_me:$LINENO: result: no" >&5
7173 echo "${ECHO_T}no" >&6
7174 fi
7175
7176   fi
7177   test -n "$ac_cv_prog_LIPO" && break
7178 done
7179
7180 if test -z "$ac_cv_prog_LIPO" ; then
7181   set dummy lipo
7182   if test $build = $host ; then
7183     LIPO="$2"
7184   else
7185     LIPO="${ncn_tool_prefix}$2"
7186   fi
7187 fi
7188
7189
7190
7191 if test -n "$NM"; then
7192   ac_cv_prog_NM=$NM
7193 elif test -n "$ac_cv_prog_NM"; then
7194   NM=$ac_cv_prog_NM
7195 fi
7196
7197 if test -n "$ac_cv_prog_NM"; then
7198   for ncn_progname in nm; do
7199     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7200 set dummy ${ncn_progname}; ac_word=$2
7201 echo "$as_me:$LINENO: checking for $ac_word" >&5
7202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7203 if test "${ac_cv_prog_NM+set}" = set; then
7204   echo $ECHO_N "(cached) $ECHO_C" >&6
7205 else
7206   if test -n "$NM"; then
7207   ac_cv_prog_NM="$NM" # Let the user override the test.
7208 else
7209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7210 for as_dir in $PATH
7211 do
7212   IFS=$as_save_IFS
7213   test -z "$as_dir" && as_dir=.
7214   for ac_exec_ext in '' $ac_executable_extensions; do
7215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7216     ac_cv_prog_NM="${ncn_progname}"
7217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7218     break 2
7219   fi
7220 done
7221 done
7222
7223 fi
7224 fi
7225 NM=$ac_cv_prog_NM
7226 if test -n "$NM"; then
7227   echo "$as_me:$LINENO: result: $NM" >&5
7228 echo "${ECHO_T}$NM" >&6
7229 else
7230   echo "$as_me:$LINENO: result: no" >&5
7231 echo "${ECHO_T}no" >&6
7232 fi
7233
7234   done
7235 fi
7236
7237 for ncn_progname in nm; do
7238   if test -n "$ncn_tool_prefix"; then
7239     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7240 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7241 echo "$as_me:$LINENO: checking for $ac_word" >&5
7242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7243 if test "${ac_cv_prog_NM+set}" = set; then
7244   echo $ECHO_N "(cached) $ECHO_C" >&6
7245 else
7246   if test -n "$NM"; then
7247   ac_cv_prog_NM="$NM" # Let the user override the test.
7248 else
7249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7250 for as_dir in $PATH
7251 do
7252   IFS=$as_save_IFS
7253   test -z "$as_dir" && as_dir=.
7254   for ac_exec_ext in '' $ac_executable_extensions; do
7255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7256     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7258     break 2
7259   fi
7260 done
7261 done
7262
7263 fi
7264 fi
7265 NM=$ac_cv_prog_NM
7266 if test -n "$NM"; then
7267   echo "$as_me:$LINENO: result: $NM" >&5
7268 echo "${ECHO_T}$NM" >&6
7269 else
7270   echo "$as_me:$LINENO: result: no" >&5
7271 echo "${ECHO_T}no" >&6
7272 fi
7273
7274   fi
7275   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7276     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7277 set dummy ${ncn_progname}; ac_word=$2
7278 echo "$as_me:$LINENO: checking for $ac_word" >&5
7279 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7280 if test "${ac_cv_prog_NM+set}" = set; then
7281   echo $ECHO_N "(cached) $ECHO_C" >&6
7282 else
7283   if test -n "$NM"; then
7284   ac_cv_prog_NM="$NM" # Let the user override the test.
7285 else
7286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7287 for as_dir in $PATH
7288 do
7289   IFS=$as_save_IFS
7290   test -z "$as_dir" && as_dir=.
7291   for ac_exec_ext in '' $ac_executable_extensions; do
7292   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7293     ac_cv_prog_NM="${ncn_progname}"
7294     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7295     break 2
7296   fi
7297 done
7298 done
7299
7300 fi
7301 fi
7302 NM=$ac_cv_prog_NM
7303 if test -n "$NM"; then
7304   echo "$as_me:$LINENO: result: $NM" >&5
7305 echo "${ECHO_T}$NM" >&6
7306 else
7307   echo "$as_me:$LINENO: result: no" >&5
7308 echo "${ECHO_T}no" >&6
7309 fi
7310
7311   fi
7312   test -n "$ac_cv_prog_NM" && break
7313 done
7314
7315 if test -z "$ac_cv_prog_NM" ; then
7316   set dummy nm
7317   if test $build = $host ; then
7318     NM="$2"
7319   else
7320     NM="${ncn_tool_prefix}$2"
7321   fi
7322 fi
7323
7324
7325
7326 if test -n "$RANLIB"; then
7327   ac_cv_prog_RANLIB=$RANLIB
7328 elif test -n "$ac_cv_prog_RANLIB"; then
7329   RANLIB=$ac_cv_prog_RANLIB
7330 fi
7331
7332 if test -n "$ac_cv_prog_RANLIB"; then
7333   for ncn_progname in ranlib; do
7334     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7335 set dummy ${ncn_progname}; ac_word=$2
7336 echo "$as_me:$LINENO: checking for $ac_word" >&5
7337 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7338 if test "${ac_cv_prog_RANLIB+set}" = set; then
7339   echo $ECHO_N "(cached) $ECHO_C" >&6
7340 else
7341   if test -n "$RANLIB"; then
7342   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7343 else
7344 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7345 for as_dir in $PATH
7346 do
7347   IFS=$as_save_IFS
7348   test -z "$as_dir" && as_dir=.
7349   for ac_exec_ext in '' $ac_executable_extensions; do
7350   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7351     ac_cv_prog_RANLIB="${ncn_progname}"
7352     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7353     break 2
7354   fi
7355 done
7356 done
7357
7358 fi
7359 fi
7360 RANLIB=$ac_cv_prog_RANLIB
7361 if test -n "$RANLIB"; then
7362   echo "$as_me:$LINENO: result: $RANLIB" >&5
7363 echo "${ECHO_T}$RANLIB" >&6
7364 else
7365   echo "$as_me:$LINENO: result: no" >&5
7366 echo "${ECHO_T}no" >&6
7367 fi
7368
7369   done
7370 fi
7371
7372 for ncn_progname in ranlib; do
7373   if test -n "$ncn_tool_prefix"; then
7374     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7375 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7376 echo "$as_me:$LINENO: checking for $ac_word" >&5
7377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7378 if test "${ac_cv_prog_RANLIB+set}" = set; then
7379   echo $ECHO_N "(cached) $ECHO_C" >&6
7380 else
7381   if test -n "$RANLIB"; then
7382   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7383 else
7384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7385 for as_dir in $PATH
7386 do
7387   IFS=$as_save_IFS
7388   test -z "$as_dir" && as_dir=.
7389   for ac_exec_ext in '' $ac_executable_extensions; do
7390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7391     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7393     break 2
7394   fi
7395 done
7396 done
7397
7398 fi
7399 fi
7400 RANLIB=$ac_cv_prog_RANLIB
7401 if test -n "$RANLIB"; then
7402   echo "$as_me:$LINENO: result: $RANLIB" >&5
7403 echo "${ECHO_T}$RANLIB" >&6
7404 else
7405   echo "$as_me:$LINENO: result: no" >&5
7406 echo "${ECHO_T}no" >&6
7407 fi
7408
7409   fi
7410   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7411     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7412 set dummy ${ncn_progname}; ac_word=$2
7413 echo "$as_me:$LINENO: checking for $ac_word" >&5
7414 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7415 if test "${ac_cv_prog_RANLIB+set}" = set; then
7416   echo $ECHO_N "(cached) $ECHO_C" >&6
7417 else
7418   if test -n "$RANLIB"; then
7419   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7420 else
7421 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7422 for as_dir in $PATH
7423 do
7424   IFS=$as_save_IFS
7425   test -z "$as_dir" && as_dir=.
7426   for ac_exec_ext in '' $ac_executable_extensions; do
7427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7428     ac_cv_prog_RANLIB="${ncn_progname}"
7429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7430     break 2
7431   fi
7432 done
7433 done
7434
7435 fi
7436 fi
7437 RANLIB=$ac_cv_prog_RANLIB
7438 if test -n "$RANLIB"; then
7439   echo "$as_me:$LINENO: result: $RANLIB" >&5
7440 echo "${ECHO_T}$RANLIB" >&6
7441 else
7442   echo "$as_me:$LINENO: result: no" >&5
7443 echo "${ECHO_T}no" >&6
7444 fi
7445
7446   fi
7447   test -n "$ac_cv_prog_RANLIB" && break
7448 done
7449
7450 if test -z "$ac_cv_prog_RANLIB" ; then
7451   RANLIB=":"
7452 fi
7453
7454
7455
7456 if test -n "$STRIP"; then
7457   ac_cv_prog_STRIP=$STRIP
7458 elif test -n "$ac_cv_prog_STRIP"; then
7459   STRIP=$ac_cv_prog_STRIP
7460 fi
7461
7462 if test -n "$ac_cv_prog_STRIP"; then
7463   for ncn_progname in strip; do
7464     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7465 set dummy ${ncn_progname}; ac_word=$2
7466 echo "$as_me:$LINENO: checking for $ac_word" >&5
7467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7468 if test "${ac_cv_prog_STRIP+set}" = set; then
7469   echo $ECHO_N "(cached) $ECHO_C" >&6
7470 else
7471   if test -n "$STRIP"; then
7472   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7473 else
7474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7475 for as_dir in $PATH
7476 do
7477   IFS=$as_save_IFS
7478   test -z "$as_dir" && as_dir=.
7479   for ac_exec_ext in '' $ac_executable_extensions; do
7480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7481     ac_cv_prog_STRIP="${ncn_progname}"
7482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7483     break 2
7484   fi
7485 done
7486 done
7487
7488 fi
7489 fi
7490 STRIP=$ac_cv_prog_STRIP
7491 if test -n "$STRIP"; then
7492   echo "$as_me:$LINENO: result: $STRIP" >&5
7493 echo "${ECHO_T}$STRIP" >&6
7494 else
7495   echo "$as_me:$LINENO: result: no" >&5
7496 echo "${ECHO_T}no" >&6
7497 fi
7498
7499   done
7500 fi
7501
7502 for ncn_progname in strip; do
7503   if test -n "$ncn_tool_prefix"; then
7504     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7505 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7506 echo "$as_me:$LINENO: checking for $ac_word" >&5
7507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7508 if test "${ac_cv_prog_STRIP+set}" = set; then
7509   echo $ECHO_N "(cached) $ECHO_C" >&6
7510 else
7511   if test -n "$STRIP"; then
7512   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7513 else
7514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7515 for as_dir in $PATH
7516 do
7517   IFS=$as_save_IFS
7518   test -z "$as_dir" && as_dir=.
7519   for ac_exec_ext in '' $ac_executable_extensions; do
7520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7521     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7523     break 2
7524   fi
7525 done
7526 done
7527
7528 fi
7529 fi
7530 STRIP=$ac_cv_prog_STRIP
7531 if test -n "$STRIP"; then
7532   echo "$as_me:$LINENO: result: $STRIP" >&5
7533 echo "${ECHO_T}$STRIP" >&6
7534 else
7535   echo "$as_me:$LINENO: result: no" >&5
7536 echo "${ECHO_T}no" >&6
7537 fi
7538
7539   fi
7540   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7541     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7542 set dummy ${ncn_progname}; ac_word=$2
7543 echo "$as_me:$LINENO: checking for $ac_word" >&5
7544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7545 if test "${ac_cv_prog_STRIP+set}" = set; then
7546   echo $ECHO_N "(cached) $ECHO_C" >&6
7547 else
7548   if test -n "$STRIP"; then
7549   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7550 else
7551 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7552 for as_dir in $PATH
7553 do
7554   IFS=$as_save_IFS
7555   test -z "$as_dir" && as_dir=.
7556   for ac_exec_ext in '' $ac_executable_extensions; do
7557   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7558     ac_cv_prog_STRIP="${ncn_progname}"
7559     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7560     break 2
7561   fi
7562 done
7563 done
7564
7565 fi
7566 fi
7567 STRIP=$ac_cv_prog_STRIP
7568 if test -n "$STRIP"; then
7569   echo "$as_me:$LINENO: result: $STRIP" >&5
7570 echo "${ECHO_T}$STRIP" >&6
7571 else
7572   echo "$as_me:$LINENO: result: no" >&5
7573 echo "${ECHO_T}no" >&6
7574 fi
7575
7576   fi
7577   test -n "$ac_cv_prog_STRIP" && break
7578 done
7579
7580 if test -z "$ac_cv_prog_STRIP" ; then
7581   STRIP=":"
7582 fi
7583
7584
7585
7586 if test -n "$WINDRES"; then
7587   ac_cv_prog_WINDRES=$WINDRES
7588 elif test -n "$ac_cv_prog_WINDRES"; then
7589   WINDRES=$ac_cv_prog_WINDRES
7590 fi
7591
7592 if test -n "$ac_cv_prog_WINDRES"; then
7593   for ncn_progname in windres; do
7594     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7595 set dummy ${ncn_progname}; ac_word=$2
7596 echo "$as_me:$LINENO: checking for $ac_word" >&5
7597 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7598 if test "${ac_cv_prog_WINDRES+set}" = set; then
7599   echo $ECHO_N "(cached) $ECHO_C" >&6
7600 else
7601   if test -n "$WINDRES"; then
7602   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7603 else
7604 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7605 for as_dir in $PATH
7606 do
7607   IFS=$as_save_IFS
7608   test -z "$as_dir" && as_dir=.
7609   for ac_exec_ext in '' $ac_executable_extensions; do
7610   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7611     ac_cv_prog_WINDRES="${ncn_progname}"
7612     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7613     break 2
7614   fi
7615 done
7616 done
7617
7618 fi
7619 fi
7620 WINDRES=$ac_cv_prog_WINDRES
7621 if test -n "$WINDRES"; then
7622   echo "$as_me:$LINENO: result: $WINDRES" >&5
7623 echo "${ECHO_T}$WINDRES" >&6
7624 else
7625   echo "$as_me:$LINENO: result: no" >&5
7626 echo "${ECHO_T}no" >&6
7627 fi
7628
7629   done
7630 fi
7631
7632 for ncn_progname in windres; do
7633   if test -n "$ncn_tool_prefix"; then
7634     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7635 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7636 echo "$as_me:$LINENO: checking for $ac_word" >&5
7637 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7638 if test "${ac_cv_prog_WINDRES+set}" = set; then
7639   echo $ECHO_N "(cached) $ECHO_C" >&6
7640 else
7641   if test -n "$WINDRES"; then
7642   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7643 else
7644 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7645 for as_dir in $PATH
7646 do
7647   IFS=$as_save_IFS
7648   test -z "$as_dir" && as_dir=.
7649   for ac_exec_ext in '' $ac_executable_extensions; do
7650   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7651     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7652     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7653     break 2
7654   fi
7655 done
7656 done
7657
7658 fi
7659 fi
7660 WINDRES=$ac_cv_prog_WINDRES
7661 if test -n "$WINDRES"; then
7662   echo "$as_me:$LINENO: result: $WINDRES" >&5
7663 echo "${ECHO_T}$WINDRES" >&6
7664 else
7665   echo "$as_me:$LINENO: result: no" >&5
7666 echo "${ECHO_T}no" >&6
7667 fi
7668
7669   fi
7670   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7671     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7672 set dummy ${ncn_progname}; ac_word=$2
7673 echo "$as_me:$LINENO: checking for $ac_word" >&5
7674 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7675 if test "${ac_cv_prog_WINDRES+set}" = set; then
7676   echo $ECHO_N "(cached) $ECHO_C" >&6
7677 else
7678   if test -n "$WINDRES"; then
7679   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7680 else
7681 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7682 for as_dir in $PATH
7683 do
7684   IFS=$as_save_IFS
7685   test -z "$as_dir" && as_dir=.
7686   for ac_exec_ext in '' $ac_executable_extensions; do
7687   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7688     ac_cv_prog_WINDRES="${ncn_progname}"
7689     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7690     break 2
7691   fi
7692 done
7693 done
7694
7695 fi
7696 fi
7697 WINDRES=$ac_cv_prog_WINDRES
7698 if test -n "$WINDRES"; then
7699   echo "$as_me:$LINENO: result: $WINDRES" >&5
7700 echo "${ECHO_T}$WINDRES" >&6
7701 else
7702   echo "$as_me:$LINENO: result: no" >&5
7703 echo "${ECHO_T}no" >&6
7704 fi
7705
7706   fi
7707   test -n "$ac_cv_prog_WINDRES" && break
7708 done
7709
7710 if test -z "$ac_cv_prog_WINDRES" ; then
7711   set dummy windres
7712   if test $build = $host ; then
7713     WINDRES="$2"
7714   else
7715     WINDRES="${ncn_tool_prefix}$2"
7716   fi
7717 fi
7718
7719
7720
7721 if test -n "$WINDMC"; then
7722   ac_cv_prog_WINDMC=$WINDMC
7723 elif test -n "$ac_cv_prog_WINDMC"; then
7724   WINDMC=$ac_cv_prog_WINDMC
7725 fi
7726
7727 if test -n "$ac_cv_prog_WINDMC"; then
7728   for ncn_progname in windmc; do
7729     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7730 set dummy ${ncn_progname}; ac_word=$2
7731 echo "$as_me:$LINENO: checking for $ac_word" >&5
7732 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7733 if test "${ac_cv_prog_WINDMC+set}" = set; then
7734   echo $ECHO_N "(cached) $ECHO_C" >&6
7735 else
7736   if test -n "$WINDMC"; then
7737   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7738 else
7739 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7740 for as_dir in $PATH
7741 do
7742   IFS=$as_save_IFS
7743   test -z "$as_dir" && as_dir=.
7744   for ac_exec_ext in '' $ac_executable_extensions; do
7745   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7746     ac_cv_prog_WINDMC="${ncn_progname}"
7747     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7748     break 2
7749   fi
7750 done
7751 done
7752
7753 fi
7754 fi
7755 WINDMC=$ac_cv_prog_WINDMC
7756 if test -n "$WINDMC"; then
7757   echo "$as_me:$LINENO: result: $WINDMC" >&5
7758 echo "${ECHO_T}$WINDMC" >&6
7759 else
7760   echo "$as_me:$LINENO: result: no" >&5
7761 echo "${ECHO_T}no" >&6
7762 fi
7763
7764   done
7765 fi
7766
7767 for ncn_progname in windmc; do
7768   if test -n "$ncn_tool_prefix"; then
7769     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7770 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7771 echo "$as_me:$LINENO: checking for $ac_word" >&5
7772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7773 if test "${ac_cv_prog_WINDMC+set}" = set; then
7774   echo $ECHO_N "(cached) $ECHO_C" >&6
7775 else
7776   if test -n "$WINDMC"; then
7777   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7778 else
7779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7780 for as_dir in $PATH
7781 do
7782   IFS=$as_save_IFS
7783   test -z "$as_dir" && as_dir=.
7784   for ac_exec_ext in '' $ac_executable_extensions; do
7785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7786     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7788     break 2
7789   fi
7790 done
7791 done
7792
7793 fi
7794 fi
7795 WINDMC=$ac_cv_prog_WINDMC
7796 if test -n "$WINDMC"; then
7797   echo "$as_me:$LINENO: result: $WINDMC" >&5
7798 echo "${ECHO_T}$WINDMC" >&6
7799 else
7800   echo "$as_me:$LINENO: result: no" >&5
7801 echo "${ECHO_T}no" >&6
7802 fi
7803
7804   fi
7805   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7806     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7807 set dummy ${ncn_progname}; ac_word=$2
7808 echo "$as_me:$LINENO: checking for $ac_word" >&5
7809 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7810 if test "${ac_cv_prog_WINDMC+set}" = set; then
7811   echo $ECHO_N "(cached) $ECHO_C" >&6
7812 else
7813   if test -n "$WINDMC"; then
7814   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7815 else
7816 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7817 for as_dir in $PATH
7818 do
7819   IFS=$as_save_IFS
7820   test -z "$as_dir" && as_dir=.
7821   for ac_exec_ext in '' $ac_executable_extensions; do
7822   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7823     ac_cv_prog_WINDMC="${ncn_progname}"
7824     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7825     break 2
7826   fi
7827 done
7828 done
7829
7830 fi
7831 fi
7832 WINDMC=$ac_cv_prog_WINDMC
7833 if test -n "$WINDMC"; then
7834   echo "$as_me:$LINENO: result: $WINDMC" >&5
7835 echo "${ECHO_T}$WINDMC" >&6
7836 else
7837   echo "$as_me:$LINENO: result: no" >&5
7838 echo "${ECHO_T}no" >&6
7839 fi
7840
7841   fi
7842   test -n "$ac_cv_prog_WINDMC" && break
7843 done
7844
7845 if test -z "$ac_cv_prog_WINDMC" ; then
7846   set dummy windmc
7847   if test $build = $host ; then
7848     WINDMC="$2"
7849   else
7850     WINDMC="${ncn_tool_prefix}$2"
7851   fi
7852 fi
7853
7854
7855
7856 if test -n "$OBJCOPY"; then
7857   ac_cv_prog_OBJCOPY=$OBJCOPY
7858 elif test -n "$ac_cv_prog_OBJCOPY"; then
7859   OBJCOPY=$ac_cv_prog_OBJCOPY
7860 fi
7861
7862 if test -n "$ac_cv_prog_OBJCOPY"; then
7863   for ncn_progname in objcopy; do
7864     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7865 set dummy ${ncn_progname}; ac_word=$2
7866 echo "$as_me:$LINENO: checking for $ac_word" >&5
7867 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7868 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7869   echo $ECHO_N "(cached) $ECHO_C" >&6
7870 else
7871   if test -n "$OBJCOPY"; then
7872   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7873 else
7874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7875 for as_dir in $PATH
7876 do
7877   IFS=$as_save_IFS
7878   test -z "$as_dir" && as_dir=.
7879   for ac_exec_ext in '' $ac_executable_extensions; do
7880   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7881     ac_cv_prog_OBJCOPY="${ncn_progname}"
7882     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7883     break 2
7884   fi
7885 done
7886 done
7887
7888 fi
7889 fi
7890 OBJCOPY=$ac_cv_prog_OBJCOPY
7891 if test -n "$OBJCOPY"; then
7892   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7893 echo "${ECHO_T}$OBJCOPY" >&6
7894 else
7895   echo "$as_me:$LINENO: result: no" >&5
7896 echo "${ECHO_T}no" >&6
7897 fi
7898
7899   done
7900 fi
7901
7902 for ncn_progname in objcopy; do
7903   if test -n "$ncn_tool_prefix"; then
7904     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7905 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7906 echo "$as_me:$LINENO: checking for $ac_word" >&5
7907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7908 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7909   echo $ECHO_N "(cached) $ECHO_C" >&6
7910 else
7911   if test -n "$OBJCOPY"; then
7912   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7913 else
7914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7915 for as_dir in $PATH
7916 do
7917   IFS=$as_save_IFS
7918   test -z "$as_dir" && as_dir=.
7919   for ac_exec_ext in '' $ac_executable_extensions; do
7920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7921     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7923     break 2
7924   fi
7925 done
7926 done
7927
7928 fi
7929 fi
7930 OBJCOPY=$ac_cv_prog_OBJCOPY
7931 if test -n "$OBJCOPY"; then
7932   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7933 echo "${ECHO_T}$OBJCOPY" >&6
7934 else
7935   echo "$as_me:$LINENO: result: no" >&5
7936 echo "${ECHO_T}no" >&6
7937 fi
7938
7939   fi
7940   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7941     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7942 set dummy ${ncn_progname}; ac_word=$2
7943 echo "$as_me:$LINENO: checking for $ac_word" >&5
7944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7945 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7946   echo $ECHO_N "(cached) $ECHO_C" >&6
7947 else
7948   if test -n "$OBJCOPY"; then
7949   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7950 else
7951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7952 for as_dir in $PATH
7953 do
7954   IFS=$as_save_IFS
7955   test -z "$as_dir" && as_dir=.
7956   for ac_exec_ext in '' $ac_executable_extensions; do
7957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7958     ac_cv_prog_OBJCOPY="${ncn_progname}"
7959     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7960     break 2
7961   fi
7962 done
7963 done
7964
7965 fi
7966 fi
7967 OBJCOPY=$ac_cv_prog_OBJCOPY
7968 if test -n "$OBJCOPY"; then
7969   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7970 echo "${ECHO_T}$OBJCOPY" >&6
7971 else
7972   echo "$as_me:$LINENO: result: no" >&5
7973 echo "${ECHO_T}no" >&6
7974 fi
7975
7976   fi
7977   test -n "$ac_cv_prog_OBJCOPY" && break
7978 done
7979
7980 if test -z "$ac_cv_prog_OBJCOPY" ; then
7981   set dummy objcopy
7982   if test $build = $host ; then
7983     OBJCOPY="$2"
7984   else
7985     OBJCOPY="${ncn_tool_prefix}$2"
7986   fi
7987 fi
7988
7989
7990
7991 if test -n "$OBJDUMP"; then
7992   ac_cv_prog_OBJDUMP=$OBJDUMP
7993 elif test -n "$ac_cv_prog_OBJDUMP"; then
7994   OBJDUMP=$ac_cv_prog_OBJDUMP
7995 fi
7996
7997 if test -n "$ac_cv_prog_OBJDUMP"; then
7998   for ncn_progname in objdump; do
7999     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8000 set dummy ${ncn_progname}; ac_word=$2
8001 echo "$as_me:$LINENO: checking for $ac_word" >&5
8002 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8003 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8004   echo $ECHO_N "(cached) $ECHO_C" >&6
8005 else
8006   if test -n "$OBJDUMP"; then
8007   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8008 else
8009 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8010 for as_dir in $PATH
8011 do
8012   IFS=$as_save_IFS
8013   test -z "$as_dir" && as_dir=.
8014   for ac_exec_ext in '' $ac_executable_extensions; do
8015   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8016     ac_cv_prog_OBJDUMP="${ncn_progname}"
8017     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8018     break 2
8019   fi
8020 done
8021 done
8022
8023 fi
8024 fi
8025 OBJDUMP=$ac_cv_prog_OBJDUMP
8026 if test -n "$OBJDUMP"; then
8027   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8028 echo "${ECHO_T}$OBJDUMP" >&6
8029 else
8030   echo "$as_me:$LINENO: result: no" >&5
8031 echo "${ECHO_T}no" >&6
8032 fi
8033
8034   done
8035 fi
8036
8037 for ncn_progname in objdump; do
8038   if test -n "$ncn_tool_prefix"; then
8039     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8040 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8041 echo "$as_me:$LINENO: checking for $ac_word" >&5
8042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8043 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8044   echo $ECHO_N "(cached) $ECHO_C" >&6
8045 else
8046   if test -n "$OBJDUMP"; then
8047   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8048 else
8049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8050 for as_dir in $PATH
8051 do
8052   IFS=$as_save_IFS
8053   test -z "$as_dir" && as_dir=.
8054   for ac_exec_ext in '' $ac_executable_extensions; do
8055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8056     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8058     break 2
8059   fi
8060 done
8061 done
8062
8063 fi
8064 fi
8065 OBJDUMP=$ac_cv_prog_OBJDUMP
8066 if test -n "$OBJDUMP"; then
8067   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8068 echo "${ECHO_T}$OBJDUMP" >&6
8069 else
8070   echo "$as_me:$LINENO: result: no" >&5
8071 echo "${ECHO_T}no" >&6
8072 fi
8073
8074   fi
8075   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8076     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8077 set dummy ${ncn_progname}; ac_word=$2
8078 echo "$as_me:$LINENO: checking for $ac_word" >&5
8079 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8080 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8081   echo $ECHO_N "(cached) $ECHO_C" >&6
8082 else
8083   if test -n "$OBJDUMP"; then
8084   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8085 else
8086 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8087 for as_dir in $PATH
8088 do
8089   IFS=$as_save_IFS
8090   test -z "$as_dir" && as_dir=.
8091   for ac_exec_ext in '' $ac_executable_extensions; do
8092   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8093     ac_cv_prog_OBJDUMP="${ncn_progname}"
8094     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8095     break 2
8096   fi
8097 done
8098 done
8099
8100 fi
8101 fi
8102 OBJDUMP=$ac_cv_prog_OBJDUMP
8103 if test -n "$OBJDUMP"; then
8104   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8105 echo "${ECHO_T}$OBJDUMP" >&6
8106 else
8107   echo "$as_me:$LINENO: result: no" >&5
8108 echo "${ECHO_T}no" >&6
8109 fi
8110
8111   fi
8112   test -n "$ac_cv_prog_OBJDUMP" && break
8113 done
8114
8115 if test -z "$ac_cv_prog_OBJDUMP" ; then
8116   set dummy objdump
8117   if test $build = $host ; then
8118     OBJDUMP="$2"
8119   else
8120     OBJDUMP="${ncn_tool_prefix}$2"
8121   fi
8122 fi
8123
8124
8125
8126
8127
8128
8129 # Target tools.
8130
8131 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8132 if test "${with_build_time_tools+set}" = set; then
8133   withval="$with_build_time_tools"
8134   case x"$withval" in
8135      x/*) ;;
8136      *)
8137        with_build_time_tools=
8138        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8139 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8140        ;;
8141    esac
8142 else
8143   with_build_time_tools=
8144 fi;
8145
8146
8147
8148 if test -n "$CC_FOR_TARGET"; then
8149   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8150 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8151   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8152 fi
8153
8154 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8155   for ncn_progname in cc gcc; do
8156     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8157 set dummy ${ncn_progname}; ac_word=$2
8158 echo "$as_me:$LINENO: checking for $ac_word" >&5
8159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8160 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8161   echo $ECHO_N "(cached) $ECHO_C" >&6
8162 else
8163   if test -n "$CC_FOR_TARGET"; then
8164   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8165 else
8166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8167 for as_dir in $PATH
8168 do
8169   IFS=$as_save_IFS
8170   test -z "$as_dir" && as_dir=.
8171   for ac_exec_ext in '' $ac_executable_extensions; do
8172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8173     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8175     break 2
8176   fi
8177 done
8178 done
8179
8180 fi
8181 fi
8182 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8183 if test -n "$CC_FOR_TARGET"; then
8184   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8185 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8186 else
8187   echo "$as_me:$LINENO: result: no" >&5
8188 echo "${ECHO_T}no" >&6
8189 fi
8190
8191   done
8192 fi
8193
8194 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8195   for ncn_progname in cc gcc; do
8196     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8197 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8198     if test -x $with_build_time_tools/${ncn_progname}; then
8199       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8200       echo "$as_me:$LINENO: result: yes" >&5
8201 echo "${ECHO_T}yes" >&6
8202       break
8203     else
8204       echo "$as_me:$LINENO: result: no" >&5
8205 echo "${ECHO_T}no" >&6
8206     fi
8207   done
8208 fi
8209
8210 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8211   for ncn_progname in cc gcc; do
8212     if test -n "$ncn_target_tool_prefix"; then
8213       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8214 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8215 echo "$as_me:$LINENO: checking for $ac_word" >&5
8216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8217 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8218   echo $ECHO_N "(cached) $ECHO_C" >&6
8219 else
8220   if test -n "$CC_FOR_TARGET"; then
8221   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8222 else
8223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8224 for as_dir in $PATH
8225 do
8226   IFS=$as_save_IFS
8227   test -z "$as_dir" && as_dir=.
8228   for ac_exec_ext in '' $ac_executable_extensions; do
8229   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8230     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8231     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8232     break 2
8233   fi
8234 done
8235 done
8236
8237 fi
8238 fi
8239 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8240 if test -n "$CC_FOR_TARGET"; then
8241   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8242 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8243 else
8244   echo "$as_me:$LINENO: result: no" >&5
8245 echo "${ECHO_T}no" >&6
8246 fi
8247
8248     fi
8249     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8250       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8251 set dummy ${ncn_progname}; ac_word=$2
8252 echo "$as_me:$LINENO: checking for $ac_word" >&5
8253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8254 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8255   echo $ECHO_N "(cached) $ECHO_C" >&6
8256 else
8257   if test -n "$CC_FOR_TARGET"; then
8258   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8259 else
8260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8261 for as_dir in $PATH
8262 do
8263   IFS=$as_save_IFS
8264   test -z "$as_dir" && as_dir=.
8265   for ac_exec_ext in '' $ac_executable_extensions; do
8266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8267     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8269     break 2
8270   fi
8271 done
8272 done
8273
8274 fi
8275 fi
8276 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8277 if test -n "$CC_FOR_TARGET"; then
8278   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8279 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8280 else
8281   echo "$as_me:$LINENO: result: no" >&5
8282 echo "${ECHO_T}no" >&6
8283 fi
8284
8285     fi
8286     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8287   done
8288 fi
8289
8290 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8291   set dummy cc gcc
8292   if test $build = $target ; then
8293     CC_FOR_TARGET="$2"
8294   else
8295     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8296   fi
8297 else
8298   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8299 fi
8300
8301
8302
8303 if test -n "$CXX_FOR_TARGET"; then
8304   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8305 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8306   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8307 fi
8308
8309 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8310   for ncn_progname in c++ g++ cxx gxx; do
8311     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8312 set dummy ${ncn_progname}; ac_word=$2
8313 echo "$as_me:$LINENO: checking for $ac_word" >&5
8314 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8315 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8316   echo $ECHO_N "(cached) $ECHO_C" >&6
8317 else
8318   if test -n "$CXX_FOR_TARGET"; then
8319   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8320 else
8321 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8322 for as_dir in $PATH
8323 do
8324   IFS=$as_save_IFS
8325   test -z "$as_dir" && as_dir=.
8326   for ac_exec_ext in '' $ac_executable_extensions; do
8327   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8328     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8329     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8330     break 2
8331   fi
8332 done
8333 done
8334
8335 fi
8336 fi
8337 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8338 if test -n "$CXX_FOR_TARGET"; then
8339   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8340 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8341 else
8342   echo "$as_me:$LINENO: result: no" >&5
8343 echo "${ECHO_T}no" >&6
8344 fi
8345
8346   done
8347 fi
8348
8349 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8350   for ncn_progname in c++ g++ cxx gxx; do
8351     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8352 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8353     if test -x $with_build_time_tools/${ncn_progname}; then
8354       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8355       echo "$as_me:$LINENO: result: yes" >&5
8356 echo "${ECHO_T}yes" >&6
8357       break
8358     else
8359       echo "$as_me:$LINENO: result: no" >&5
8360 echo "${ECHO_T}no" >&6
8361     fi
8362   done
8363 fi
8364
8365 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8366   for ncn_progname in c++ g++ cxx gxx; do
8367     if test -n "$ncn_target_tool_prefix"; then
8368       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8369 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8370 echo "$as_me:$LINENO: checking for $ac_word" >&5
8371 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8372 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8373   echo $ECHO_N "(cached) $ECHO_C" >&6
8374 else
8375   if test -n "$CXX_FOR_TARGET"; then
8376   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8377 else
8378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8379 for as_dir in $PATH
8380 do
8381   IFS=$as_save_IFS
8382   test -z "$as_dir" && as_dir=.
8383   for ac_exec_ext in '' $ac_executable_extensions; do
8384   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8385     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8386     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8387     break 2
8388   fi
8389 done
8390 done
8391
8392 fi
8393 fi
8394 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8395 if test -n "$CXX_FOR_TARGET"; then
8396   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8397 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8398 else
8399   echo "$as_me:$LINENO: result: no" >&5
8400 echo "${ECHO_T}no" >&6
8401 fi
8402
8403     fi
8404     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8405       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8406 set dummy ${ncn_progname}; ac_word=$2
8407 echo "$as_me:$LINENO: checking for $ac_word" >&5
8408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8409 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8410   echo $ECHO_N "(cached) $ECHO_C" >&6
8411 else
8412   if test -n "$CXX_FOR_TARGET"; then
8413   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8414 else
8415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8416 for as_dir in $PATH
8417 do
8418   IFS=$as_save_IFS
8419   test -z "$as_dir" && as_dir=.
8420   for ac_exec_ext in '' $ac_executable_extensions; do
8421   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8422     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8423     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8424     break 2
8425   fi
8426 done
8427 done
8428
8429 fi
8430 fi
8431 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8432 if test -n "$CXX_FOR_TARGET"; then
8433   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8434 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8435 else
8436   echo "$as_me:$LINENO: result: no" >&5
8437 echo "${ECHO_T}no" >&6
8438 fi
8439
8440     fi
8441     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8442   done
8443 fi
8444
8445 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8446   set dummy c++ g++ cxx gxx
8447   if test $build = $target ; then
8448     CXX_FOR_TARGET="$2"
8449   else
8450     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8451   fi
8452 else
8453   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8454 fi
8455
8456
8457
8458 if test -n "$GCC_FOR_TARGET"; then
8459   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8460 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8461   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8462 fi
8463
8464 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8465   for ncn_progname in gcc; do
8466     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8467 set dummy ${ncn_progname}; ac_word=$2
8468 echo "$as_me:$LINENO: checking for $ac_word" >&5
8469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8470 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8471   echo $ECHO_N "(cached) $ECHO_C" >&6
8472 else
8473   if test -n "$GCC_FOR_TARGET"; then
8474   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8475 else
8476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8477 for as_dir in $PATH
8478 do
8479   IFS=$as_save_IFS
8480   test -z "$as_dir" && as_dir=.
8481   for ac_exec_ext in '' $ac_executable_extensions; do
8482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8483     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8485     break 2
8486   fi
8487 done
8488 done
8489
8490 fi
8491 fi
8492 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8493 if test -n "$GCC_FOR_TARGET"; then
8494   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8495 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8496 else
8497   echo "$as_me:$LINENO: result: no" >&5
8498 echo "${ECHO_T}no" >&6
8499 fi
8500
8501   done
8502 fi
8503
8504 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8505   for ncn_progname in gcc; do
8506     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8507 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8508     if test -x $with_build_time_tools/${ncn_progname}; then
8509       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8510       echo "$as_me:$LINENO: result: yes" >&5
8511 echo "${ECHO_T}yes" >&6
8512       break
8513     else
8514       echo "$as_me:$LINENO: result: no" >&5
8515 echo "${ECHO_T}no" >&6
8516     fi
8517   done
8518 fi
8519
8520 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8521   for ncn_progname in gcc; do
8522     if test -n "$ncn_target_tool_prefix"; then
8523       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8524 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8525 echo "$as_me:$LINENO: checking for $ac_word" >&5
8526 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8527 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8528   echo $ECHO_N "(cached) $ECHO_C" >&6
8529 else
8530   if test -n "$GCC_FOR_TARGET"; then
8531   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8532 else
8533 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8534 for as_dir in $PATH
8535 do
8536   IFS=$as_save_IFS
8537   test -z "$as_dir" && as_dir=.
8538   for ac_exec_ext in '' $ac_executable_extensions; do
8539   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8540     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8541     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8542     break 2
8543   fi
8544 done
8545 done
8546
8547 fi
8548 fi
8549 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8550 if test -n "$GCC_FOR_TARGET"; then
8551   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8552 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8553 else
8554   echo "$as_me:$LINENO: result: no" >&5
8555 echo "${ECHO_T}no" >&6
8556 fi
8557
8558     fi
8559     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8560       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8561 set dummy ${ncn_progname}; ac_word=$2
8562 echo "$as_me:$LINENO: checking for $ac_word" >&5
8563 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8564 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8565   echo $ECHO_N "(cached) $ECHO_C" >&6
8566 else
8567   if test -n "$GCC_FOR_TARGET"; then
8568   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8569 else
8570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8571 for as_dir in $PATH
8572 do
8573   IFS=$as_save_IFS
8574   test -z "$as_dir" && as_dir=.
8575   for ac_exec_ext in '' $ac_executable_extensions; do
8576   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8577     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8578     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8579     break 2
8580   fi
8581 done
8582 done
8583
8584 fi
8585 fi
8586 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8587 if test -n "$GCC_FOR_TARGET"; then
8588   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8589 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8590 else
8591   echo "$as_me:$LINENO: result: no" >&5
8592 echo "${ECHO_T}no" >&6
8593 fi
8594
8595     fi
8596     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8597   done
8598 fi
8599
8600 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8601   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8602 else
8603   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8604 fi
8605
8606
8607
8608 if test -n "$GCJ_FOR_TARGET"; then
8609   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8610 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8611   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8612 fi
8613
8614 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8615   for ncn_progname in gcj; do
8616     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8617 set dummy ${ncn_progname}; ac_word=$2
8618 echo "$as_me:$LINENO: checking for $ac_word" >&5
8619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8620 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8621   echo $ECHO_N "(cached) $ECHO_C" >&6
8622 else
8623   if test -n "$GCJ_FOR_TARGET"; then
8624   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8625 else
8626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8627 for as_dir in $PATH
8628 do
8629   IFS=$as_save_IFS
8630   test -z "$as_dir" && as_dir=.
8631   for ac_exec_ext in '' $ac_executable_extensions; do
8632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8633     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8635     break 2
8636   fi
8637 done
8638 done
8639
8640 fi
8641 fi
8642 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8643 if test -n "$GCJ_FOR_TARGET"; then
8644   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8645 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8646 else
8647   echo "$as_me:$LINENO: result: no" >&5
8648 echo "${ECHO_T}no" >&6
8649 fi
8650
8651   done
8652 fi
8653
8654 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8655   for ncn_progname in gcj; do
8656     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8657 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8658     if test -x $with_build_time_tools/${ncn_progname}; then
8659       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8660       echo "$as_me:$LINENO: result: yes" >&5
8661 echo "${ECHO_T}yes" >&6
8662       break
8663     else
8664       echo "$as_me:$LINENO: result: no" >&5
8665 echo "${ECHO_T}no" >&6
8666     fi
8667   done
8668 fi
8669
8670 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8671   for ncn_progname in gcj; do
8672     if test -n "$ncn_target_tool_prefix"; then
8673       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8674 set dummy ${ncn_target_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_GCJ_FOR_TARGET+set}" = set; then
8678   echo $ECHO_N "(cached) $ECHO_C" >&6
8679 else
8680   if test -n "$GCJ_FOR_TARGET"; then
8681   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # 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_GCJ_FOR_TARGET="${ncn_target_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 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8700 if test -n "$GCJ_FOR_TARGET"; then
8701   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8702 echo "${ECHO_T}$GCJ_FOR_TARGET" >&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_GCJ_FOR_TARGET" && test $build = $target ; 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_GCJ_FOR_TARGET+set}" = set; then
8715   echo $ECHO_N "(cached) $ECHO_C" >&6
8716 else
8717   if test -n "$GCJ_FOR_TARGET"; then
8718   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # 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_GCJ_FOR_TARGET="${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 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8737 if test -n "$GCJ_FOR_TARGET"; then
8738   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8739 echo "${ECHO_T}$GCJ_FOR_TARGET" >&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_GCJ_FOR_TARGET" && break
8747   done
8748 fi
8749
8750 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8751   set dummy gcj
8752   if test $build = $target ; then
8753     GCJ_FOR_TARGET="$2"
8754   else
8755     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8756   fi
8757 else
8758   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8759 fi
8760
8761
8762
8763 if test -n "$GFORTRAN_FOR_TARGET"; then
8764   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8765 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8766   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8767 fi
8768
8769 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8770   for ncn_progname in gfortran; do
8771     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8772 set dummy ${ncn_progname}; ac_word=$2
8773 echo "$as_me:$LINENO: checking for $ac_word" >&5
8774 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8775 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8776   echo $ECHO_N "(cached) $ECHO_C" >&6
8777 else
8778   if test -n "$GFORTRAN_FOR_TARGET"; then
8779   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8780 else
8781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8782 for as_dir in $PATH
8783 do
8784   IFS=$as_save_IFS
8785   test -z "$as_dir" && as_dir=.
8786   for ac_exec_ext in '' $ac_executable_extensions; do
8787   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8788     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8789     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8790     break 2
8791   fi
8792 done
8793 done
8794
8795 fi
8796 fi
8797 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8798 if test -n "$GFORTRAN_FOR_TARGET"; then
8799   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8800 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8801 else
8802   echo "$as_me:$LINENO: result: no" >&5
8803 echo "${ECHO_T}no" >&6
8804 fi
8805
8806   done
8807 fi
8808
8809 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8810   for ncn_progname in gfortran; do
8811     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8812 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8813     if test -x $with_build_time_tools/${ncn_progname}; then
8814       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8815       echo "$as_me:$LINENO: result: yes" >&5
8816 echo "${ECHO_T}yes" >&6
8817       break
8818     else
8819       echo "$as_me:$LINENO: result: no" >&5
8820 echo "${ECHO_T}no" >&6
8821     fi
8822   done
8823 fi
8824
8825 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8826   for ncn_progname in gfortran; do
8827     if test -n "$ncn_target_tool_prefix"; then
8828       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8829 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8830 echo "$as_me:$LINENO: checking for $ac_word" >&5
8831 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8832 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8833   echo $ECHO_N "(cached) $ECHO_C" >&6
8834 else
8835   if test -n "$GFORTRAN_FOR_TARGET"; then
8836   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8837 else
8838 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8839 for as_dir in $PATH
8840 do
8841   IFS=$as_save_IFS
8842   test -z "$as_dir" && as_dir=.
8843   for ac_exec_ext in '' $ac_executable_extensions; do
8844   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8845     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8846     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8847     break 2
8848   fi
8849 done
8850 done
8851
8852 fi
8853 fi
8854 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8855 if test -n "$GFORTRAN_FOR_TARGET"; then
8856   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8857 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8858 else
8859   echo "$as_me:$LINENO: result: no" >&5
8860 echo "${ECHO_T}no" >&6
8861 fi
8862
8863     fi
8864     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8865       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8866 set dummy ${ncn_progname}; ac_word=$2
8867 echo "$as_me:$LINENO: checking for $ac_word" >&5
8868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8869 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8870   echo $ECHO_N "(cached) $ECHO_C" >&6
8871 else
8872   if test -n "$GFORTRAN_FOR_TARGET"; then
8873   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8874 else
8875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8876 for as_dir in $PATH
8877 do
8878   IFS=$as_save_IFS
8879   test -z "$as_dir" && as_dir=.
8880   for ac_exec_ext in '' $ac_executable_extensions; do
8881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8882     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8884     break 2
8885   fi
8886 done
8887 done
8888
8889 fi
8890 fi
8891 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8892 if test -n "$GFORTRAN_FOR_TARGET"; then
8893   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8894 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8895 else
8896   echo "$as_me:$LINENO: result: no" >&5
8897 echo "${ECHO_T}no" >&6
8898 fi
8899
8900     fi
8901     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8902   done
8903 fi
8904
8905 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8906   set dummy gfortran
8907   if test $build = $target ; then
8908     GFORTRAN_FOR_TARGET="$2"
8909   else
8910     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8911   fi
8912 else
8913   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8914 fi
8915
8916
8917
8918 cat > conftest.c << \EOF
8919 #ifdef __GNUC__
8920   gcc_yay;
8921 #endif
8922 EOF
8923 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8924   have_gcc_for_target=yes
8925 else
8926   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8927   have_gcc_for_target=no
8928 fi
8929 rm conftest.c
8930
8931
8932
8933
8934 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8935   if test -n "$with_build_time_tools"; then
8936     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8937 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8938     if test -x $with_build_time_tools/ar; then
8939       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8940       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8941       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8942 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8943     else
8944       echo "$as_me:$LINENO: result: no" >&5
8945 echo "${ECHO_T}no" >&6
8946     fi
8947   elif test $build != $host && test $have_gcc_for_target = yes; then
8948     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8949     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8950     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8951   fi
8952 fi
8953 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8954   # Extract the first word of "ar", so it can be a program name with args.
8955 set dummy ar; ac_word=$2
8956 echo "$as_me:$LINENO: checking for $ac_word" >&5
8957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8958 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8959   echo $ECHO_N "(cached) $ECHO_C" >&6
8960 else
8961   case $AR_FOR_TARGET in
8962   [\\/]* | ?:[\\/]*)
8963   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8964   ;;
8965   *)
8966   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8967 for as_dir in $gcc_cv_tool_dirs
8968 do
8969   IFS=$as_save_IFS
8970   test -z "$as_dir" && as_dir=.
8971   for ac_exec_ext in '' $ac_executable_extensions; do
8972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8973     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8975     break 2
8976   fi
8977 done
8978 done
8979
8980   ;;
8981 esac
8982 fi
8983 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8984
8985 if test -n "$AR_FOR_TARGET"; then
8986   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8987 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8988 else
8989   echo "$as_me:$LINENO: result: no" >&5
8990 echo "${ECHO_T}no" >&6
8991 fi
8992
8993 fi
8994 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8995
8996
8997 if test -n "$AR_FOR_TARGET"; then
8998   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8999 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9000   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9001 fi
9002
9003 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9004   for ncn_progname in ar; do
9005     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9006 set dummy ${ncn_progname}; ac_word=$2
9007 echo "$as_me:$LINENO: checking for $ac_word" >&5
9008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9009 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9010   echo $ECHO_N "(cached) $ECHO_C" >&6
9011 else
9012   if test -n "$AR_FOR_TARGET"; then
9013   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9014 else
9015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9016 for as_dir in $PATH
9017 do
9018   IFS=$as_save_IFS
9019   test -z "$as_dir" && as_dir=.
9020   for ac_exec_ext in '' $ac_executable_extensions; do
9021   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9022     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9023     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9024     break 2
9025   fi
9026 done
9027 done
9028
9029 fi
9030 fi
9031 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9032 if test -n "$AR_FOR_TARGET"; then
9033   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9034 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9035 else
9036   echo "$as_me:$LINENO: result: no" >&5
9037 echo "${ECHO_T}no" >&6
9038 fi
9039
9040   done
9041 fi
9042
9043 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9044   for ncn_progname in ar; do
9045     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9046 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9047     if test -x $with_build_time_tools/${ncn_progname}; then
9048       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9049       echo "$as_me:$LINENO: result: yes" >&5
9050 echo "${ECHO_T}yes" >&6
9051       break
9052     else
9053       echo "$as_me:$LINENO: result: no" >&5
9054 echo "${ECHO_T}no" >&6
9055     fi
9056   done
9057 fi
9058
9059 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9060   for ncn_progname in ar; do
9061     if test -n "$ncn_target_tool_prefix"; then
9062       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9063 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9064 echo "$as_me:$LINENO: checking for $ac_word" >&5
9065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9066 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9067   echo $ECHO_N "(cached) $ECHO_C" >&6
9068 else
9069   if test -n "$AR_FOR_TARGET"; then
9070   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9071 else
9072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9073 for as_dir in $PATH
9074 do
9075   IFS=$as_save_IFS
9076   test -z "$as_dir" && as_dir=.
9077   for ac_exec_ext in '' $ac_executable_extensions; do
9078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9079     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9081     break 2
9082   fi
9083 done
9084 done
9085
9086 fi
9087 fi
9088 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9089 if test -n "$AR_FOR_TARGET"; then
9090   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9091 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9092 else
9093   echo "$as_me:$LINENO: result: no" >&5
9094 echo "${ECHO_T}no" >&6
9095 fi
9096
9097     fi
9098     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9099       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9100 set dummy ${ncn_progname}; ac_word=$2
9101 echo "$as_me:$LINENO: checking for $ac_word" >&5
9102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9103 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9104   echo $ECHO_N "(cached) $ECHO_C" >&6
9105 else
9106   if test -n "$AR_FOR_TARGET"; then
9107   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9108 else
9109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9110 for as_dir in $PATH
9111 do
9112   IFS=$as_save_IFS
9113   test -z "$as_dir" && as_dir=.
9114   for ac_exec_ext in '' $ac_executable_extensions; do
9115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9116     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9118     break 2
9119   fi
9120 done
9121 done
9122
9123 fi
9124 fi
9125 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9126 if test -n "$AR_FOR_TARGET"; then
9127   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9128 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9129 else
9130   echo "$as_me:$LINENO: result: no" >&5
9131 echo "${ECHO_T}no" >&6
9132 fi
9133
9134     fi
9135     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9136   done
9137 fi
9138
9139 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9140   set dummy ar
9141   if test $build = $target ; then
9142     AR_FOR_TARGET="$2"
9143   else
9144     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9145   fi
9146 else
9147   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9148 fi
9149
9150 else
9151   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9152 fi
9153
9154
9155
9156
9157 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9158   if test -n "$with_build_time_tools"; then
9159     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9160 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9161     if test -x $with_build_time_tools/as; then
9162       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9163       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9164       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9165 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9166     else
9167       echo "$as_me:$LINENO: result: no" >&5
9168 echo "${ECHO_T}no" >&6
9169     fi
9170   elif test $build != $host && test $have_gcc_for_target = yes; then
9171     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9172     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9173     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9174   fi
9175 fi
9176 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9177   # Extract the first word of "as", so it can be a program name with args.
9178 set dummy as; ac_word=$2
9179 echo "$as_me:$LINENO: checking for $ac_word" >&5
9180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9181 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9182   echo $ECHO_N "(cached) $ECHO_C" >&6
9183 else
9184   case $AS_FOR_TARGET in
9185   [\\/]* | ?:[\\/]*)
9186   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9187   ;;
9188   *)
9189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9190 for as_dir in $gcc_cv_tool_dirs
9191 do
9192   IFS=$as_save_IFS
9193   test -z "$as_dir" && as_dir=.
9194   for ac_exec_ext in '' $ac_executable_extensions; do
9195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9196     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9198     break 2
9199   fi
9200 done
9201 done
9202
9203   ;;
9204 esac
9205 fi
9206 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9207
9208 if test -n "$AS_FOR_TARGET"; then
9209   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9210 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9211 else
9212   echo "$as_me:$LINENO: result: no" >&5
9213 echo "${ECHO_T}no" >&6
9214 fi
9215
9216 fi
9217 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9218
9219
9220 if test -n "$AS_FOR_TARGET"; then
9221   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9222 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9223   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9224 fi
9225
9226 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9227   for ncn_progname in as; do
9228     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9229 set dummy ${ncn_progname}; ac_word=$2
9230 echo "$as_me:$LINENO: checking for $ac_word" >&5
9231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9232 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9233   echo $ECHO_N "(cached) $ECHO_C" >&6
9234 else
9235   if test -n "$AS_FOR_TARGET"; then
9236   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9237 else
9238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9239 for as_dir in $PATH
9240 do
9241   IFS=$as_save_IFS
9242   test -z "$as_dir" && as_dir=.
9243   for ac_exec_ext in '' $ac_executable_extensions; do
9244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9245     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9247     break 2
9248   fi
9249 done
9250 done
9251
9252 fi
9253 fi
9254 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9255 if test -n "$AS_FOR_TARGET"; then
9256   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9257 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9258 else
9259   echo "$as_me:$LINENO: result: no" >&5
9260 echo "${ECHO_T}no" >&6
9261 fi
9262
9263   done
9264 fi
9265
9266 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9267   for ncn_progname in as; do
9268     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9269 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9270     if test -x $with_build_time_tools/${ncn_progname}; then
9271       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9272       echo "$as_me:$LINENO: result: yes" >&5
9273 echo "${ECHO_T}yes" >&6
9274       break
9275     else
9276       echo "$as_me:$LINENO: result: no" >&5
9277 echo "${ECHO_T}no" >&6
9278     fi
9279   done
9280 fi
9281
9282 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9283   for ncn_progname in as; do
9284     if test -n "$ncn_target_tool_prefix"; then
9285       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9286 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9287 echo "$as_me:$LINENO: checking for $ac_word" >&5
9288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9289 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9290   echo $ECHO_N "(cached) $ECHO_C" >&6
9291 else
9292   if test -n "$AS_FOR_TARGET"; then
9293   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9294 else
9295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9296 for as_dir in $PATH
9297 do
9298   IFS=$as_save_IFS
9299   test -z "$as_dir" && as_dir=.
9300   for ac_exec_ext in '' $ac_executable_extensions; do
9301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9302     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9304     break 2
9305   fi
9306 done
9307 done
9308
9309 fi
9310 fi
9311 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9312 if test -n "$AS_FOR_TARGET"; then
9313   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9314 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9315 else
9316   echo "$as_me:$LINENO: result: no" >&5
9317 echo "${ECHO_T}no" >&6
9318 fi
9319
9320     fi
9321     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9322       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9323 set dummy ${ncn_progname}; ac_word=$2
9324 echo "$as_me:$LINENO: checking for $ac_word" >&5
9325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9326 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9327   echo $ECHO_N "(cached) $ECHO_C" >&6
9328 else
9329   if test -n "$AS_FOR_TARGET"; then
9330   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9331 else
9332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9333 for as_dir in $PATH
9334 do
9335   IFS=$as_save_IFS
9336   test -z "$as_dir" && as_dir=.
9337   for ac_exec_ext in '' $ac_executable_extensions; do
9338   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9339     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9340     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9341     break 2
9342   fi
9343 done
9344 done
9345
9346 fi
9347 fi
9348 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9349 if test -n "$AS_FOR_TARGET"; then
9350   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9351 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9352 else
9353   echo "$as_me:$LINENO: result: no" >&5
9354 echo "${ECHO_T}no" >&6
9355 fi
9356
9357     fi
9358     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9359   done
9360 fi
9361
9362 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9363   set dummy as
9364   if test $build = $target ; then
9365     AS_FOR_TARGET="$2"
9366   else
9367     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9368   fi
9369 else
9370   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9371 fi
9372
9373 else
9374   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9375 fi
9376
9377
9378
9379
9380 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9381   if test -n "$with_build_time_tools"; then
9382     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9383 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9384     if test -x $with_build_time_tools/dlltool; then
9385       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9386       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9387       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9388 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9389     else
9390       echo "$as_me:$LINENO: result: no" >&5
9391 echo "${ECHO_T}no" >&6
9392     fi
9393   elif test $build != $host && test $have_gcc_for_target = yes; then
9394     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9395     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9396     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9397   fi
9398 fi
9399 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9400   # Extract the first word of "dlltool", so it can be a program name with args.
9401 set dummy dlltool; ac_word=$2
9402 echo "$as_me:$LINENO: checking for $ac_word" >&5
9403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9404 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9405   echo $ECHO_N "(cached) $ECHO_C" >&6
9406 else
9407   case $DLLTOOL_FOR_TARGET in
9408   [\\/]* | ?:[\\/]*)
9409   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9410   ;;
9411   *)
9412   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9413 for as_dir in $gcc_cv_tool_dirs
9414 do
9415   IFS=$as_save_IFS
9416   test -z "$as_dir" && as_dir=.
9417   for ac_exec_ext in '' $ac_executable_extensions; do
9418   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9419     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9420     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9421     break 2
9422   fi
9423 done
9424 done
9425
9426   ;;
9427 esac
9428 fi
9429 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9430
9431 if test -n "$DLLTOOL_FOR_TARGET"; then
9432   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9433 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9434 else
9435   echo "$as_me:$LINENO: result: no" >&5
9436 echo "${ECHO_T}no" >&6
9437 fi
9438
9439 fi
9440 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9441
9442
9443 if test -n "$DLLTOOL_FOR_TARGET"; then
9444   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9445 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9446   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9447 fi
9448
9449 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9450   for ncn_progname in dlltool; do
9451     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9452 set dummy ${ncn_progname}; ac_word=$2
9453 echo "$as_me:$LINENO: checking for $ac_word" >&5
9454 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9455 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9456   echo $ECHO_N "(cached) $ECHO_C" >&6
9457 else
9458   if test -n "$DLLTOOL_FOR_TARGET"; then
9459   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9460 else
9461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9462 for as_dir in $PATH
9463 do
9464   IFS=$as_save_IFS
9465   test -z "$as_dir" && as_dir=.
9466   for ac_exec_ext in '' $ac_executable_extensions; do
9467   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9468     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9469     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9470     break 2
9471   fi
9472 done
9473 done
9474
9475 fi
9476 fi
9477 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9478 if test -n "$DLLTOOL_FOR_TARGET"; then
9479   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9480 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9481 else
9482   echo "$as_me:$LINENO: result: no" >&5
9483 echo "${ECHO_T}no" >&6
9484 fi
9485
9486   done
9487 fi
9488
9489 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9490   for ncn_progname in dlltool; do
9491     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9492 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9493     if test -x $with_build_time_tools/${ncn_progname}; then
9494       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9495       echo "$as_me:$LINENO: result: yes" >&5
9496 echo "${ECHO_T}yes" >&6
9497       break
9498     else
9499       echo "$as_me:$LINENO: result: no" >&5
9500 echo "${ECHO_T}no" >&6
9501     fi
9502   done
9503 fi
9504
9505 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9506   for ncn_progname in dlltool; do
9507     if test -n "$ncn_target_tool_prefix"; then
9508       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9509 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9510 echo "$as_me:$LINENO: checking for $ac_word" >&5
9511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9512 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9513   echo $ECHO_N "(cached) $ECHO_C" >&6
9514 else
9515   if test -n "$DLLTOOL_FOR_TARGET"; then
9516   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9517 else
9518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9519 for as_dir in $PATH
9520 do
9521   IFS=$as_save_IFS
9522   test -z "$as_dir" && as_dir=.
9523   for ac_exec_ext in '' $ac_executable_extensions; do
9524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9525     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9527     break 2
9528   fi
9529 done
9530 done
9531
9532 fi
9533 fi
9534 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9535 if test -n "$DLLTOOL_FOR_TARGET"; then
9536   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9537 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9538 else
9539   echo "$as_me:$LINENO: result: no" >&5
9540 echo "${ECHO_T}no" >&6
9541 fi
9542
9543     fi
9544     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9545       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9546 set dummy ${ncn_progname}; ac_word=$2
9547 echo "$as_me:$LINENO: checking for $ac_word" >&5
9548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9549 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9550   echo $ECHO_N "(cached) $ECHO_C" >&6
9551 else
9552   if test -n "$DLLTOOL_FOR_TARGET"; then
9553   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9554 else
9555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9556 for as_dir in $PATH
9557 do
9558   IFS=$as_save_IFS
9559   test -z "$as_dir" && as_dir=.
9560   for ac_exec_ext in '' $ac_executable_extensions; do
9561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9562     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9564     break 2
9565   fi
9566 done
9567 done
9568
9569 fi
9570 fi
9571 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9572 if test -n "$DLLTOOL_FOR_TARGET"; then
9573   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9574 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9575 else
9576   echo "$as_me:$LINENO: result: no" >&5
9577 echo "${ECHO_T}no" >&6
9578 fi
9579
9580     fi
9581     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9582   done
9583 fi
9584
9585 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9586   set dummy dlltool
9587   if test $build = $target ; then
9588     DLLTOOL_FOR_TARGET="$2"
9589   else
9590     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9591   fi
9592 else
9593   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9594 fi
9595
9596 else
9597   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9598 fi
9599
9600
9601
9602
9603 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9604   if test -n "$with_build_time_tools"; then
9605     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9606 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9607     if test -x $with_build_time_tools/ld; then
9608       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9609       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9610       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9611 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9612     else
9613       echo "$as_me:$LINENO: result: no" >&5
9614 echo "${ECHO_T}no" >&6
9615     fi
9616   elif test $build != $host && test $have_gcc_for_target = yes; then
9617     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9618     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9619     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9620   fi
9621 fi
9622 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9623   # Extract the first word of "ld", so it can be a program name with args.
9624 set dummy ld; ac_word=$2
9625 echo "$as_me:$LINENO: checking for $ac_word" >&5
9626 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9627 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9628   echo $ECHO_N "(cached) $ECHO_C" >&6
9629 else
9630   case $LD_FOR_TARGET in
9631   [\\/]* | ?:[\\/]*)
9632   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9633   ;;
9634   *)
9635   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9636 for as_dir in $gcc_cv_tool_dirs
9637 do
9638   IFS=$as_save_IFS
9639   test -z "$as_dir" && as_dir=.
9640   for ac_exec_ext in '' $ac_executable_extensions; do
9641   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9642     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9643     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9644     break 2
9645   fi
9646 done
9647 done
9648
9649   ;;
9650 esac
9651 fi
9652 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9653
9654 if test -n "$LD_FOR_TARGET"; then
9655   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9656 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9657 else
9658   echo "$as_me:$LINENO: result: no" >&5
9659 echo "${ECHO_T}no" >&6
9660 fi
9661
9662 fi
9663 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9664
9665
9666 if test -n "$LD_FOR_TARGET"; then
9667   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9668 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9669   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9670 fi
9671
9672 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9673   for ncn_progname in ld; do
9674     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9675 set dummy ${ncn_progname}; ac_word=$2
9676 echo "$as_me:$LINENO: checking for $ac_word" >&5
9677 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9678 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9679   echo $ECHO_N "(cached) $ECHO_C" >&6
9680 else
9681   if test -n "$LD_FOR_TARGET"; then
9682   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9683 else
9684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9685 for as_dir in $PATH
9686 do
9687   IFS=$as_save_IFS
9688   test -z "$as_dir" && as_dir=.
9689   for ac_exec_ext in '' $ac_executable_extensions; do
9690   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9691     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9692     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9693     break 2
9694   fi
9695 done
9696 done
9697
9698 fi
9699 fi
9700 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9701 if test -n "$LD_FOR_TARGET"; then
9702   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9703 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9704 else
9705   echo "$as_me:$LINENO: result: no" >&5
9706 echo "${ECHO_T}no" >&6
9707 fi
9708
9709   done
9710 fi
9711
9712 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9713   for ncn_progname in ld; do
9714     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9715 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9716     if test -x $with_build_time_tools/${ncn_progname}; then
9717       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9718       echo "$as_me:$LINENO: result: yes" >&5
9719 echo "${ECHO_T}yes" >&6
9720       break
9721     else
9722       echo "$as_me:$LINENO: result: no" >&5
9723 echo "${ECHO_T}no" >&6
9724     fi
9725   done
9726 fi
9727
9728 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9729   for ncn_progname in ld; do
9730     if test -n "$ncn_target_tool_prefix"; then
9731       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9732 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9733 echo "$as_me:$LINENO: checking for $ac_word" >&5
9734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9735 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9736   echo $ECHO_N "(cached) $ECHO_C" >&6
9737 else
9738   if test -n "$LD_FOR_TARGET"; then
9739   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9740 else
9741 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9742 for as_dir in $PATH
9743 do
9744   IFS=$as_save_IFS
9745   test -z "$as_dir" && as_dir=.
9746   for ac_exec_ext in '' $ac_executable_extensions; do
9747   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9748     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9749     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9750     break 2
9751   fi
9752 done
9753 done
9754
9755 fi
9756 fi
9757 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9758 if test -n "$LD_FOR_TARGET"; then
9759   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9760 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9761 else
9762   echo "$as_me:$LINENO: result: no" >&5
9763 echo "${ECHO_T}no" >&6
9764 fi
9765
9766     fi
9767     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9768       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9769 set dummy ${ncn_progname}; ac_word=$2
9770 echo "$as_me:$LINENO: checking for $ac_word" >&5
9771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9772 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9773   echo $ECHO_N "(cached) $ECHO_C" >&6
9774 else
9775   if test -n "$LD_FOR_TARGET"; then
9776   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9777 else
9778 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9779 for as_dir in $PATH
9780 do
9781   IFS=$as_save_IFS
9782   test -z "$as_dir" && as_dir=.
9783   for ac_exec_ext in '' $ac_executable_extensions; do
9784   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9785     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9786     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9787     break 2
9788   fi
9789 done
9790 done
9791
9792 fi
9793 fi
9794 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9795 if test -n "$LD_FOR_TARGET"; then
9796   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9797 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9798 else
9799   echo "$as_me:$LINENO: result: no" >&5
9800 echo "${ECHO_T}no" >&6
9801 fi
9802
9803     fi
9804     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9805   done
9806 fi
9807
9808 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9809   set dummy ld
9810   if test $build = $target ; then
9811     LD_FOR_TARGET="$2"
9812   else
9813     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9814   fi
9815 else
9816   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9817 fi
9818
9819 else
9820   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9821 fi
9822
9823
9824
9825
9826 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9827   if test -n "$with_build_time_tools"; then
9828     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9829 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9830     if test -x $with_build_time_tools/lipo; then
9831       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9832       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9833       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9834 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9835     else
9836       echo "$as_me:$LINENO: result: no" >&5
9837 echo "${ECHO_T}no" >&6
9838     fi
9839   elif test $build != $host && test $have_gcc_for_target = yes; then
9840     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9841     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9842     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9843   fi
9844 fi
9845 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9846   # Extract the first word of "lipo", so it can be a program name with args.
9847 set dummy lipo; ac_word=$2
9848 echo "$as_me:$LINENO: checking for $ac_word" >&5
9849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9850 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9851   echo $ECHO_N "(cached) $ECHO_C" >&6
9852 else
9853   case $LIPO_FOR_TARGET in
9854   [\\/]* | ?:[\\/]*)
9855   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9856   ;;
9857   *)
9858   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9859 for as_dir in $gcc_cv_tool_dirs
9860 do
9861   IFS=$as_save_IFS
9862   test -z "$as_dir" && as_dir=.
9863   for ac_exec_ext in '' $ac_executable_extensions; do
9864   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9865     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9866     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9867     break 2
9868   fi
9869 done
9870 done
9871
9872   ;;
9873 esac
9874 fi
9875 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9876
9877 if test -n "$LIPO_FOR_TARGET"; then
9878   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9879 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9880 else
9881   echo "$as_me:$LINENO: result: no" >&5
9882 echo "${ECHO_T}no" >&6
9883 fi
9884
9885 fi
9886 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9887
9888
9889 if test -n "$LIPO_FOR_TARGET"; then
9890   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9891 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9892   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9893 fi
9894
9895 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9896   for ncn_progname in lipo; do
9897     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9898 set dummy ${ncn_progname}; ac_word=$2
9899 echo "$as_me:$LINENO: checking for $ac_word" >&5
9900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9901 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9902   echo $ECHO_N "(cached) $ECHO_C" >&6
9903 else
9904   if test -n "$LIPO_FOR_TARGET"; then
9905   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9906 else
9907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9908 for as_dir in $PATH
9909 do
9910   IFS=$as_save_IFS
9911   test -z "$as_dir" && as_dir=.
9912   for ac_exec_ext in '' $ac_executable_extensions; do
9913   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9914     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9915     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9916     break 2
9917   fi
9918 done
9919 done
9920
9921 fi
9922 fi
9923 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9924 if test -n "$LIPO_FOR_TARGET"; then
9925   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9926 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9927 else
9928   echo "$as_me:$LINENO: result: no" >&5
9929 echo "${ECHO_T}no" >&6
9930 fi
9931
9932   done
9933 fi
9934
9935 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9936   for ncn_progname in lipo; do
9937     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9938 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9939     if test -x $with_build_time_tools/${ncn_progname}; then
9940       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9941       echo "$as_me:$LINENO: result: yes" >&5
9942 echo "${ECHO_T}yes" >&6
9943       break
9944     else
9945       echo "$as_me:$LINENO: result: no" >&5
9946 echo "${ECHO_T}no" >&6
9947     fi
9948   done
9949 fi
9950
9951 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9952   for ncn_progname in lipo; do
9953     if test -n "$ncn_target_tool_prefix"; then
9954       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9955 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9956 echo "$as_me:$LINENO: checking for $ac_word" >&5
9957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9958 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9959   echo $ECHO_N "(cached) $ECHO_C" >&6
9960 else
9961   if test -n "$LIPO_FOR_TARGET"; then
9962   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9963 else
9964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9965 for as_dir in $PATH
9966 do
9967   IFS=$as_save_IFS
9968   test -z "$as_dir" && as_dir=.
9969   for ac_exec_ext in '' $ac_executable_extensions; do
9970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9971     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9973     break 2
9974   fi
9975 done
9976 done
9977
9978 fi
9979 fi
9980 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9981 if test -n "$LIPO_FOR_TARGET"; then
9982   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9983 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9984 else
9985   echo "$as_me:$LINENO: result: no" >&5
9986 echo "${ECHO_T}no" >&6
9987 fi
9988
9989     fi
9990     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9991       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9992 set dummy ${ncn_progname}; ac_word=$2
9993 echo "$as_me:$LINENO: checking for $ac_word" >&5
9994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9995 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9996   echo $ECHO_N "(cached) $ECHO_C" >&6
9997 else
9998   if test -n "$LIPO_FOR_TARGET"; then
9999   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10000 else
10001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10002 for as_dir in $PATH
10003 do
10004   IFS=$as_save_IFS
10005   test -z "$as_dir" && as_dir=.
10006   for ac_exec_ext in '' $ac_executable_extensions; do
10007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10008     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10010     break 2
10011   fi
10012 done
10013 done
10014
10015 fi
10016 fi
10017 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10018 if test -n "$LIPO_FOR_TARGET"; then
10019   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10020 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10021 else
10022   echo "$as_me:$LINENO: result: no" >&5
10023 echo "${ECHO_T}no" >&6
10024 fi
10025
10026     fi
10027     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10028   done
10029 fi
10030
10031 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10032   set dummy lipo
10033   if test $build = $target ; then
10034     LIPO_FOR_TARGET="$2"
10035   else
10036     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10037   fi
10038 else
10039   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10040 fi
10041
10042 else
10043   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10044 fi
10045
10046
10047
10048
10049 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10050   if test -n "$with_build_time_tools"; then
10051     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10052 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10053     if test -x $with_build_time_tools/nm; then
10054       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10055       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10056       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10057 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10058     else
10059       echo "$as_me:$LINENO: result: no" >&5
10060 echo "${ECHO_T}no" >&6
10061     fi
10062   elif test $build != $host && test $have_gcc_for_target = yes; then
10063     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10064     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10065     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10066   fi
10067 fi
10068 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10069   # Extract the first word of "nm", so it can be a program name with args.
10070 set dummy nm; ac_word=$2
10071 echo "$as_me:$LINENO: checking for $ac_word" >&5
10072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10073 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10074   echo $ECHO_N "(cached) $ECHO_C" >&6
10075 else
10076   case $NM_FOR_TARGET in
10077   [\\/]* | ?:[\\/]*)
10078   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10079   ;;
10080   *)
10081   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10082 for as_dir in $gcc_cv_tool_dirs
10083 do
10084   IFS=$as_save_IFS
10085   test -z "$as_dir" && as_dir=.
10086   for ac_exec_ext in '' $ac_executable_extensions; do
10087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10088     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10090     break 2
10091   fi
10092 done
10093 done
10094
10095   ;;
10096 esac
10097 fi
10098 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10099
10100 if test -n "$NM_FOR_TARGET"; then
10101   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10102 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10103 else
10104   echo "$as_me:$LINENO: result: no" >&5
10105 echo "${ECHO_T}no" >&6
10106 fi
10107
10108 fi
10109 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10110
10111
10112 if test -n "$NM_FOR_TARGET"; then
10113   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10114 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10115   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10116 fi
10117
10118 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10119   for ncn_progname in nm; do
10120     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10121 set dummy ${ncn_progname}; ac_word=$2
10122 echo "$as_me:$LINENO: checking for $ac_word" >&5
10123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10124 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10125   echo $ECHO_N "(cached) $ECHO_C" >&6
10126 else
10127   if test -n "$NM_FOR_TARGET"; then
10128   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10129 else
10130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10131 for as_dir in $PATH
10132 do
10133   IFS=$as_save_IFS
10134   test -z "$as_dir" && as_dir=.
10135   for ac_exec_ext in '' $ac_executable_extensions; do
10136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10137     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10139     break 2
10140   fi
10141 done
10142 done
10143
10144 fi
10145 fi
10146 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10147 if test -n "$NM_FOR_TARGET"; then
10148   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10149 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10150 else
10151   echo "$as_me:$LINENO: result: no" >&5
10152 echo "${ECHO_T}no" >&6
10153 fi
10154
10155   done
10156 fi
10157
10158 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10159   for ncn_progname in nm; do
10160     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10161 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10162     if test -x $with_build_time_tools/${ncn_progname}; then
10163       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10164       echo "$as_me:$LINENO: result: yes" >&5
10165 echo "${ECHO_T}yes" >&6
10166       break
10167     else
10168       echo "$as_me:$LINENO: result: no" >&5
10169 echo "${ECHO_T}no" >&6
10170     fi
10171   done
10172 fi
10173
10174 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10175   for ncn_progname in nm; do
10176     if test -n "$ncn_target_tool_prefix"; then
10177       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10178 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10179 echo "$as_me:$LINENO: checking for $ac_word" >&5
10180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10181 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10182   echo $ECHO_N "(cached) $ECHO_C" >&6
10183 else
10184   if test -n "$NM_FOR_TARGET"; then
10185   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10186 else
10187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10188 for as_dir in $PATH
10189 do
10190   IFS=$as_save_IFS
10191   test -z "$as_dir" && as_dir=.
10192   for ac_exec_ext in '' $ac_executable_extensions; do
10193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10194     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10196     break 2
10197   fi
10198 done
10199 done
10200
10201 fi
10202 fi
10203 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10204 if test -n "$NM_FOR_TARGET"; then
10205   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10206 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10207 else
10208   echo "$as_me:$LINENO: result: no" >&5
10209 echo "${ECHO_T}no" >&6
10210 fi
10211
10212     fi
10213     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10214       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10215 set dummy ${ncn_progname}; ac_word=$2
10216 echo "$as_me:$LINENO: checking for $ac_word" >&5
10217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10218 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10219   echo $ECHO_N "(cached) $ECHO_C" >&6
10220 else
10221   if test -n "$NM_FOR_TARGET"; then
10222   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10223 else
10224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10225 for as_dir in $PATH
10226 do
10227   IFS=$as_save_IFS
10228   test -z "$as_dir" && as_dir=.
10229   for ac_exec_ext in '' $ac_executable_extensions; do
10230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10231     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10233     break 2
10234   fi
10235 done
10236 done
10237
10238 fi
10239 fi
10240 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10241 if test -n "$NM_FOR_TARGET"; then
10242   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10243 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10244 else
10245   echo "$as_me:$LINENO: result: no" >&5
10246 echo "${ECHO_T}no" >&6
10247 fi
10248
10249     fi
10250     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10251   done
10252 fi
10253
10254 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10255   set dummy nm
10256   if test $build = $target ; then
10257     NM_FOR_TARGET="$2"
10258   else
10259     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10260   fi
10261 else
10262   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10263 fi
10264
10265 else
10266   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10267 fi
10268
10269
10270
10271
10272 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10273   if test -n "$with_build_time_tools"; then
10274     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10275 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10276     if test -x $with_build_time_tools/objdump; then
10277       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10278       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10279       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10280 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10281     else
10282       echo "$as_me:$LINENO: result: no" >&5
10283 echo "${ECHO_T}no" >&6
10284     fi
10285   elif test $build != $host && test $have_gcc_for_target = yes; then
10286     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10287     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10288     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10289   fi
10290 fi
10291 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10292   # Extract the first word of "objdump", so it can be a program name with args.
10293 set dummy objdump; ac_word=$2
10294 echo "$as_me:$LINENO: checking for $ac_word" >&5
10295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10296 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10297   echo $ECHO_N "(cached) $ECHO_C" >&6
10298 else
10299   case $OBJDUMP_FOR_TARGET in
10300   [\\/]* | ?:[\\/]*)
10301   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10302   ;;
10303   *)
10304   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10305 for as_dir in $gcc_cv_tool_dirs
10306 do
10307   IFS=$as_save_IFS
10308   test -z "$as_dir" && as_dir=.
10309   for ac_exec_ext in '' $ac_executable_extensions; do
10310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10311     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10313     break 2
10314   fi
10315 done
10316 done
10317
10318   ;;
10319 esac
10320 fi
10321 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10322
10323 if test -n "$OBJDUMP_FOR_TARGET"; then
10324   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10325 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10326 else
10327   echo "$as_me:$LINENO: result: no" >&5
10328 echo "${ECHO_T}no" >&6
10329 fi
10330
10331 fi
10332 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10333
10334
10335 if test -n "$OBJDUMP_FOR_TARGET"; then
10336   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10337 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10338   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10339 fi
10340
10341 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10342   for ncn_progname in objdump; do
10343     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10344 set dummy ${ncn_progname}; ac_word=$2
10345 echo "$as_me:$LINENO: checking for $ac_word" >&5
10346 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10347 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10348   echo $ECHO_N "(cached) $ECHO_C" >&6
10349 else
10350   if test -n "$OBJDUMP_FOR_TARGET"; then
10351   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10352 else
10353 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10354 for as_dir in $PATH
10355 do
10356   IFS=$as_save_IFS
10357   test -z "$as_dir" && as_dir=.
10358   for ac_exec_ext in '' $ac_executable_extensions; do
10359   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10360     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10361     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10362     break 2
10363   fi
10364 done
10365 done
10366
10367 fi
10368 fi
10369 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10370 if test -n "$OBJDUMP_FOR_TARGET"; then
10371   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10372 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10373 else
10374   echo "$as_me:$LINENO: result: no" >&5
10375 echo "${ECHO_T}no" >&6
10376 fi
10377
10378   done
10379 fi
10380
10381 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10382   for ncn_progname in objdump; do
10383     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10384 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10385     if test -x $with_build_time_tools/${ncn_progname}; then
10386       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10387       echo "$as_me:$LINENO: result: yes" >&5
10388 echo "${ECHO_T}yes" >&6
10389       break
10390     else
10391       echo "$as_me:$LINENO: result: no" >&5
10392 echo "${ECHO_T}no" >&6
10393     fi
10394   done
10395 fi
10396
10397 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10398   for ncn_progname in objdump; do
10399     if test -n "$ncn_target_tool_prefix"; then
10400       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10401 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10402 echo "$as_me:$LINENO: checking for $ac_word" >&5
10403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10404 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10405   echo $ECHO_N "(cached) $ECHO_C" >&6
10406 else
10407   if test -n "$OBJDUMP_FOR_TARGET"; then
10408   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10409 else
10410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10411 for as_dir in $PATH
10412 do
10413   IFS=$as_save_IFS
10414   test -z "$as_dir" && as_dir=.
10415   for ac_exec_ext in '' $ac_executable_extensions; do
10416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10417     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10419     break 2
10420   fi
10421 done
10422 done
10423
10424 fi
10425 fi
10426 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10427 if test -n "$OBJDUMP_FOR_TARGET"; then
10428   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10429 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10430 else
10431   echo "$as_me:$LINENO: result: no" >&5
10432 echo "${ECHO_T}no" >&6
10433 fi
10434
10435     fi
10436     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10437       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10438 set dummy ${ncn_progname}; ac_word=$2
10439 echo "$as_me:$LINENO: checking for $ac_word" >&5
10440 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10441 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10442   echo $ECHO_N "(cached) $ECHO_C" >&6
10443 else
10444   if test -n "$OBJDUMP_FOR_TARGET"; then
10445   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10446 else
10447 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10448 for as_dir in $PATH
10449 do
10450   IFS=$as_save_IFS
10451   test -z "$as_dir" && as_dir=.
10452   for ac_exec_ext in '' $ac_executable_extensions; do
10453   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10454     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10455     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10456     break 2
10457   fi
10458 done
10459 done
10460
10461 fi
10462 fi
10463 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10464 if test -n "$OBJDUMP_FOR_TARGET"; then
10465   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10466 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10467 else
10468   echo "$as_me:$LINENO: result: no" >&5
10469 echo "${ECHO_T}no" >&6
10470 fi
10471
10472     fi
10473     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10474   done
10475 fi
10476
10477 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10478   set dummy objdump
10479   if test $build = $target ; then
10480     OBJDUMP_FOR_TARGET="$2"
10481   else
10482     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10483   fi
10484 else
10485   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10486 fi
10487
10488 else
10489   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10490 fi
10491
10492
10493
10494
10495 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10496   if test -n "$with_build_time_tools"; then
10497     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10498 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10499     if test -x $with_build_time_tools/ranlib; then
10500       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10501       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10502       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10503 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10504     else
10505       echo "$as_me:$LINENO: result: no" >&5
10506 echo "${ECHO_T}no" >&6
10507     fi
10508   elif test $build != $host && test $have_gcc_for_target = yes; then
10509     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10510     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10511     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10512   fi
10513 fi
10514 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10515   # Extract the first word of "ranlib", so it can be a program name with args.
10516 set dummy ranlib; ac_word=$2
10517 echo "$as_me:$LINENO: checking for $ac_word" >&5
10518 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10519 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10520   echo $ECHO_N "(cached) $ECHO_C" >&6
10521 else
10522   case $RANLIB_FOR_TARGET in
10523   [\\/]* | ?:[\\/]*)
10524   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10525   ;;
10526   *)
10527   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10528 for as_dir in $gcc_cv_tool_dirs
10529 do
10530   IFS=$as_save_IFS
10531   test -z "$as_dir" && as_dir=.
10532   for ac_exec_ext in '' $ac_executable_extensions; do
10533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10534     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10536     break 2
10537   fi
10538 done
10539 done
10540
10541   ;;
10542 esac
10543 fi
10544 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10545
10546 if test -n "$RANLIB_FOR_TARGET"; then
10547   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10548 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10549 else
10550   echo "$as_me:$LINENO: result: no" >&5
10551 echo "${ECHO_T}no" >&6
10552 fi
10553
10554 fi
10555 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10556
10557
10558 if test -n "$RANLIB_FOR_TARGET"; then
10559   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10560 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10561   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10562 fi
10563
10564 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10565   for ncn_progname in ranlib; do
10566     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10567 set dummy ${ncn_progname}; ac_word=$2
10568 echo "$as_me:$LINENO: checking for $ac_word" >&5
10569 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10570 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10571   echo $ECHO_N "(cached) $ECHO_C" >&6
10572 else
10573   if test -n "$RANLIB_FOR_TARGET"; then
10574   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10575 else
10576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10577 for as_dir in $PATH
10578 do
10579   IFS=$as_save_IFS
10580   test -z "$as_dir" && as_dir=.
10581   for ac_exec_ext in '' $ac_executable_extensions; do
10582   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10583     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10584     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10585     break 2
10586   fi
10587 done
10588 done
10589
10590 fi
10591 fi
10592 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10593 if test -n "$RANLIB_FOR_TARGET"; then
10594   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10595 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10596 else
10597   echo "$as_me:$LINENO: result: no" >&5
10598 echo "${ECHO_T}no" >&6
10599 fi
10600
10601   done
10602 fi
10603
10604 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10605   for ncn_progname in ranlib; do
10606     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10607 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10608     if test -x $with_build_time_tools/${ncn_progname}; then
10609       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10610       echo "$as_me:$LINENO: result: yes" >&5
10611 echo "${ECHO_T}yes" >&6
10612       break
10613     else
10614       echo "$as_me:$LINENO: result: no" >&5
10615 echo "${ECHO_T}no" >&6
10616     fi
10617   done
10618 fi
10619
10620 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10621   for ncn_progname in ranlib; do
10622     if test -n "$ncn_target_tool_prefix"; then
10623       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10624 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10625 echo "$as_me:$LINENO: checking for $ac_word" >&5
10626 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10627 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10628   echo $ECHO_N "(cached) $ECHO_C" >&6
10629 else
10630   if test -n "$RANLIB_FOR_TARGET"; then
10631   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10632 else
10633 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10634 for as_dir in $PATH
10635 do
10636   IFS=$as_save_IFS
10637   test -z "$as_dir" && as_dir=.
10638   for ac_exec_ext in '' $ac_executable_extensions; do
10639   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10640     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10641     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10642     break 2
10643   fi
10644 done
10645 done
10646
10647 fi
10648 fi
10649 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10650 if test -n "$RANLIB_FOR_TARGET"; then
10651   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10652 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10653 else
10654   echo "$as_me:$LINENO: result: no" >&5
10655 echo "${ECHO_T}no" >&6
10656 fi
10657
10658     fi
10659     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10660       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10661 set dummy ${ncn_progname}; ac_word=$2
10662 echo "$as_me:$LINENO: checking for $ac_word" >&5
10663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10664 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10665   echo $ECHO_N "(cached) $ECHO_C" >&6
10666 else
10667   if test -n "$RANLIB_FOR_TARGET"; then
10668   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10669 else
10670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10671 for as_dir in $PATH
10672 do
10673   IFS=$as_save_IFS
10674   test -z "$as_dir" && as_dir=.
10675   for ac_exec_ext in '' $ac_executable_extensions; do
10676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10677     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10679     break 2
10680   fi
10681 done
10682 done
10683
10684 fi
10685 fi
10686 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10687 if test -n "$RANLIB_FOR_TARGET"; then
10688   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10689 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10690 else
10691   echo "$as_me:$LINENO: result: no" >&5
10692 echo "${ECHO_T}no" >&6
10693 fi
10694
10695     fi
10696     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10697   done
10698 fi
10699
10700 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10701   set dummy ranlib
10702   if test $build = $target ; then
10703     RANLIB_FOR_TARGET="$2"
10704   else
10705     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10706   fi
10707 else
10708   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10709 fi
10710
10711 else
10712   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10713 fi
10714
10715
10716
10717
10718 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10719   if test -n "$with_build_time_tools"; then
10720     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10721 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10722     if test -x $with_build_time_tools/strip; then
10723       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10724       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10725       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10726 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10727     else
10728       echo "$as_me:$LINENO: result: no" >&5
10729 echo "${ECHO_T}no" >&6
10730     fi
10731   elif test $build != $host && test $have_gcc_for_target = yes; then
10732     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10733     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10734     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10735   fi
10736 fi
10737 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10738   # Extract the first word of "strip", so it can be a program name with args.
10739 set dummy strip; ac_word=$2
10740 echo "$as_me:$LINENO: checking for $ac_word" >&5
10741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10742 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10743   echo $ECHO_N "(cached) $ECHO_C" >&6
10744 else
10745   case $STRIP_FOR_TARGET in
10746   [\\/]* | ?:[\\/]*)
10747   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10748   ;;
10749   *)
10750   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10751 for as_dir in $gcc_cv_tool_dirs
10752 do
10753   IFS=$as_save_IFS
10754   test -z "$as_dir" && as_dir=.
10755   for ac_exec_ext in '' $ac_executable_extensions; do
10756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10757     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10759     break 2
10760   fi
10761 done
10762 done
10763
10764   ;;
10765 esac
10766 fi
10767 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10768
10769 if test -n "$STRIP_FOR_TARGET"; then
10770   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10771 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10772 else
10773   echo "$as_me:$LINENO: result: no" >&5
10774 echo "${ECHO_T}no" >&6
10775 fi
10776
10777 fi
10778 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10779
10780
10781 if test -n "$STRIP_FOR_TARGET"; then
10782   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10783 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10784   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10785 fi
10786
10787 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10788   for ncn_progname in strip; do
10789     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10790 set dummy ${ncn_progname}; ac_word=$2
10791 echo "$as_me:$LINENO: checking for $ac_word" >&5
10792 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10793 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10794   echo $ECHO_N "(cached) $ECHO_C" >&6
10795 else
10796   if test -n "$STRIP_FOR_TARGET"; then
10797   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10798 else
10799 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10800 for as_dir in $PATH
10801 do
10802   IFS=$as_save_IFS
10803   test -z "$as_dir" && as_dir=.
10804   for ac_exec_ext in '' $ac_executable_extensions; do
10805   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10806     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10807     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10808     break 2
10809   fi
10810 done
10811 done
10812
10813 fi
10814 fi
10815 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10816 if test -n "$STRIP_FOR_TARGET"; then
10817   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10818 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10819 else
10820   echo "$as_me:$LINENO: result: no" >&5
10821 echo "${ECHO_T}no" >&6
10822 fi
10823
10824   done
10825 fi
10826
10827 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10828   for ncn_progname in strip; do
10829     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10830 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10831     if test -x $with_build_time_tools/${ncn_progname}; then
10832       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10833       echo "$as_me:$LINENO: result: yes" >&5
10834 echo "${ECHO_T}yes" >&6
10835       break
10836     else
10837       echo "$as_me:$LINENO: result: no" >&5
10838 echo "${ECHO_T}no" >&6
10839     fi
10840   done
10841 fi
10842
10843 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10844   for ncn_progname in strip; do
10845     if test -n "$ncn_target_tool_prefix"; then
10846       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10847 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10848 echo "$as_me:$LINENO: checking for $ac_word" >&5
10849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10850 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10851   echo $ECHO_N "(cached) $ECHO_C" >&6
10852 else
10853   if test -n "$STRIP_FOR_TARGET"; then
10854   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10855 else
10856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10857 for as_dir in $PATH
10858 do
10859   IFS=$as_save_IFS
10860   test -z "$as_dir" && as_dir=.
10861   for ac_exec_ext in '' $ac_executable_extensions; do
10862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10863     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10865     break 2
10866   fi
10867 done
10868 done
10869
10870 fi
10871 fi
10872 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10873 if test -n "$STRIP_FOR_TARGET"; then
10874   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10875 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10876 else
10877   echo "$as_me:$LINENO: result: no" >&5
10878 echo "${ECHO_T}no" >&6
10879 fi
10880
10881     fi
10882     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10883       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10884 set dummy ${ncn_progname}; ac_word=$2
10885 echo "$as_me:$LINENO: checking for $ac_word" >&5
10886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10887 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10888   echo $ECHO_N "(cached) $ECHO_C" >&6
10889 else
10890   if test -n "$STRIP_FOR_TARGET"; then
10891   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10892 else
10893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10894 for as_dir in $PATH
10895 do
10896   IFS=$as_save_IFS
10897   test -z "$as_dir" && as_dir=.
10898   for ac_exec_ext in '' $ac_executable_extensions; do
10899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10900     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10902     break 2
10903   fi
10904 done
10905 done
10906
10907 fi
10908 fi
10909 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10910 if test -n "$STRIP_FOR_TARGET"; then
10911   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10912 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10913 else
10914   echo "$as_me:$LINENO: result: no" >&5
10915 echo "${ECHO_T}no" >&6
10916 fi
10917
10918     fi
10919     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10920   done
10921 fi
10922
10923 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10924   set dummy strip
10925   if test $build = $target ; then
10926     STRIP_FOR_TARGET="$2"
10927   else
10928     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10929   fi
10930 else
10931   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10932 fi
10933
10934 else
10935   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10936 fi
10937
10938
10939
10940
10941 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10942   if test -n "$with_build_time_tools"; then
10943     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10944 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10945     if test -x $with_build_time_tools/windres; then
10946       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10947       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10948       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10949 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10950     else
10951       echo "$as_me:$LINENO: result: no" >&5
10952 echo "${ECHO_T}no" >&6
10953     fi
10954   elif test $build != $host && test $have_gcc_for_target = yes; then
10955     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10956     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10957     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10958   fi
10959 fi
10960 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10961   # Extract the first word of "windres", so it can be a program name with args.
10962 set dummy windres; ac_word=$2
10963 echo "$as_me:$LINENO: checking for $ac_word" >&5
10964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10965 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10966   echo $ECHO_N "(cached) $ECHO_C" >&6
10967 else
10968   case $WINDRES_FOR_TARGET in
10969   [\\/]* | ?:[\\/]*)
10970   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10971   ;;
10972   *)
10973   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10974 for as_dir in $gcc_cv_tool_dirs
10975 do
10976   IFS=$as_save_IFS
10977   test -z "$as_dir" && as_dir=.
10978   for ac_exec_ext in '' $ac_executable_extensions; do
10979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10980     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10982     break 2
10983   fi
10984 done
10985 done
10986
10987   ;;
10988 esac
10989 fi
10990 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10991
10992 if test -n "$WINDRES_FOR_TARGET"; then
10993   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10994 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10995 else
10996   echo "$as_me:$LINENO: result: no" >&5
10997 echo "${ECHO_T}no" >&6
10998 fi
10999
11000 fi
11001 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11002
11003
11004 if test -n "$WINDRES_FOR_TARGET"; then
11005   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11006 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11007   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11008 fi
11009
11010 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11011   for ncn_progname in windres; do
11012     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11013 set dummy ${ncn_progname}; ac_word=$2
11014 echo "$as_me:$LINENO: checking for $ac_word" >&5
11015 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11016 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11017   echo $ECHO_N "(cached) $ECHO_C" >&6
11018 else
11019   if test -n "$WINDRES_FOR_TARGET"; then
11020   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11021 else
11022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11023 for as_dir in $PATH
11024 do
11025   IFS=$as_save_IFS
11026   test -z "$as_dir" && as_dir=.
11027   for ac_exec_ext in '' $ac_executable_extensions; do
11028   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11029     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11030     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11031     break 2
11032   fi
11033 done
11034 done
11035
11036 fi
11037 fi
11038 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11039 if test -n "$WINDRES_FOR_TARGET"; then
11040   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11041 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11042 else
11043   echo "$as_me:$LINENO: result: no" >&5
11044 echo "${ECHO_T}no" >&6
11045 fi
11046
11047   done
11048 fi
11049
11050 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11051   for ncn_progname in windres; do
11052     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11053 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11054     if test -x $with_build_time_tools/${ncn_progname}; then
11055       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11056       echo "$as_me:$LINENO: result: yes" >&5
11057 echo "${ECHO_T}yes" >&6
11058       break
11059     else
11060       echo "$as_me:$LINENO: result: no" >&5
11061 echo "${ECHO_T}no" >&6
11062     fi
11063   done
11064 fi
11065
11066 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11067   for ncn_progname in windres; do
11068     if test -n "$ncn_target_tool_prefix"; then
11069       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11070 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11071 echo "$as_me:$LINENO: checking for $ac_word" >&5
11072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11073 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11074   echo $ECHO_N "(cached) $ECHO_C" >&6
11075 else
11076   if test -n "$WINDRES_FOR_TARGET"; then
11077   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11078 else
11079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11080 for as_dir in $PATH
11081 do
11082   IFS=$as_save_IFS
11083   test -z "$as_dir" && as_dir=.
11084   for ac_exec_ext in '' $ac_executable_extensions; do
11085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11086     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11088     break 2
11089   fi
11090 done
11091 done
11092
11093 fi
11094 fi
11095 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11096 if test -n "$WINDRES_FOR_TARGET"; then
11097   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11098 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11099 else
11100   echo "$as_me:$LINENO: result: no" >&5
11101 echo "${ECHO_T}no" >&6
11102 fi
11103
11104     fi
11105     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11106       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11107 set dummy ${ncn_progname}; ac_word=$2
11108 echo "$as_me:$LINENO: checking for $ac_word" >&5
11109 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11110 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11111   echo $ECHO_N "(cached) $ECHO_C" >&6
11112 else
11113   if test -n "$WINDRES_FOR_TARGET"; then
11114   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11115 else
11116 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11117 for as_dir in $PATH
11118 do
11119   IFS=$as_save_IFS
11120   test -z "$as_dir" && as_dir=.
11121   for ac_exec_ext in '' $ac_executable_extensions; do
11122   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11123     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11124     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11125     break 2
11126   fi
11127 done
11128 done
11129
11130 fi
11131 fi
11132 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11133 if test -n "$WINDRES_FOR_TARGET"; then
11134   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11135 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11136 else
11137   echo "$as_me:$LINENO: result: no" >&5
11138 echo "${ECHO_T}no" >&6
11139 fi
11140
11141     fi
11142     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11143   done
11144 fi
11145
11146 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11147   set dummy windres
11148   if test $build = $target ; then
11149     WINDRES_FOR_TARGET="$2"
11150   else
11151     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11152   fi
11153 else
11154   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11155 fi
11156
11157 else
11158   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11159 fi
11160
11161
11162
11163
11164 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11165   if test -n "$with_build_time_tools"; then
11166     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11167 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11168     if test -x $with_build_time_tools/windmc; then
11169       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11170       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11171       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11172 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11173     else
11174       echo "$as_me:$LINENO: result: no" >&5
11175 echo "${ECHO_T}no" >&6
11176     fi
11177   elif test $build != $host && test $have_gcc_for_target = yes; then
11178     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11179     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11180     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11181   fi
11182 fi
11183 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11184   # Extract the first word of "windmc", so it can be a program name with args.
11185 set dummy windmc; ac_word=$2
11186 echo "$as_me:$LINENO: checking for $ac_word" >&5
11187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11188 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11189   echo $ECHO_N "(cached) $ECHO_C" >&6
11190 else
11191   case $WINDMC_FOR_TARGET in
11192   [\\/]* | ?:[\\/]*)
11193   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11194   ;;
11195   *)
11196   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11197 for as_dir in $gcc_cv_tool_dirs
11198 do
11199   IFS=$as_save_IFS
11200   test -z "$as_dir" && as_dir=.
11201   for ac_exec_ext in '' $ac_executable_extensions; do
11202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11203     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11205     break 2
11206   fi
11207 done
11208 done
11209
11210   ;;
11211 esac
11212 fi
11213 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11214
11215 if test -n "$WINDMC_FOR_TARGET"; then
11216   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11217 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11218 else
11219   echo "$as_me:$LINENO: result: no" >&5
11220 echo "${ECHO_T}no" >&6
11221 fi
11222
11223 fi
11224 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11225
11226
11227 if test -n "$WINDMC_FOR_TARGET"; then
11228   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11229 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11230   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11231 fi
11232
11233 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11234   for ncn_progname in windmc; do
11235     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11236 set dummy ${ncn_progname}; ac_word=$2
11237 echo "$as_me:$LINENO: checking for $ac_word" >&5
11238 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11239 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11240   echo $ECHO_N "(cached) $ECHO_C" >&6
11241 else
11242   if test -n "$WINDMC_FOR_TARGET"; then
11243   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11244 else
11245 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11246 for as_dir in $PATH
11247 do
11248   IFS=$as_save_IFS
11249   test -z "$as_dir" && as_dir=.
11250   for ac_exec_ext in '' $ac_executable_extensions; do
11251   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11252     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11253     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11254     break 2
11255   fi
11256 done
11257 done
11258
11259 fi
11260 fi
11261 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11262 if test -n "$WINDMC_FOR_TARGET"; then
11263   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11264 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11265 else
11266   echo "$as_me:$LINENO: result: no" >&5
11267 echo "${ECHO_T}no" >&6
11268 fi
11269
11270   done
11271 fi
11272
11273 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11274   for ncn_progname in windmc; do
11275     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11276 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11277     if test -x $with_build_time_tools/${ncn_progname}; then
11278       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11279       echo "$as_me:$LINENO: result: yes" >&5
11280 echo "${ECHO_T}yes" >&6
11281       break
11282     else
11283       echo "$as_me:$LINENO: result: no" >&5
11284 echo "${ECHO_T}no" >&6
11285     fi
11286   done
11287 fi
11288
11289 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11290   for ncn_progname in windmc; do
11291     if test -n "$ncn_target_tool_prefix"; then
11292       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11293 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11294 echo "$as_me:$LINENO: checking for $ac_word" >&5
11295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11296 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11297   echo $ECHO_N "(cached) $ECHO_C" >&6
11298 else
11299   if test -n "$WINDMC_FOR_TARGET"; then
11300   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11301 else
11302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11303 for as_dir in $PATH
11304 do
11305   IFS=$as_save_IFS
11306   test -z "$as_dir" && as_dir=.
11307   for ac_exec_ext in '' $ac_executable_extensions; do
11308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11309     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11311     break 2
11312   fi
11313 done
11314 done
11315
11316 fi
11317 fi
11318 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11319 if test -n "$WINDMC_FOR_TARGET"; then
11320   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11321 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11322 else
11323   echo "$as_me:$LINENO: result: no" >&5
11324 echo "${ECHO_T}no" >&6
11325 fi
11326
11327     fi
11328     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11329       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11330 set dummy ${ncn_progname}; ac_word=$2
11331 echo "$as_me:$LINENO: checking for $ac_word" >&5
11332 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11333 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11334   echo $ECHO_N "(cached) $ECHO_C" >&6
11335 else
11336   if test -n "$WINDMC_FOR_TARGET"; then
11337   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11338 else
11339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11340 for as_dir in $PATH
11341 do
11342   IFS=$as_save_IFS
11343   test -z "$as_dir" && as_dir=.
11344   for ac_exec_ext in '' $ac_executable_extensions; do
11345   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11346     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11347     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11348     break 2
11349   fi
11350 done
11351 done
11352
11353 fi
11354 fi
11355 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11356 if test -n "$WINDMC_FOR_TARGET"; then
11357   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11358 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11359 else
11360   echo "$as_me:$LINENO: result: no" >&5
11361 echo "${ECHO_T}no" >&6
11362 fi
11363
11364     fi
11365     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11366   done
11367 fi
11368
11369 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11370   set dummy windmc
11371   if test $build = $target ; then
11372     WINDMC_FOR_TARGET="$2"
11373   else
11374     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11375   fi
11376 else
11377   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11378 fi
11379
11380 else
11381   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11382 fi
11383
11384
11385 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11386
11387 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11388 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11389 if test "x${build}" != "x${host}" ; then
11390   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11391     # We already found the complete path
11392     ac_dir=`dirname $AR_FOR_TARGET`
11393     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11394 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11395   else
11396     # Canadian cross, just use what we found
11397     echo "$as_me:$LINENO: result: pre-installed" >&5
11398 echo "${ECHO_T}pre-installed" >&6
11399   fi
11400 else
11401   ok=yes
11402   case " ${configdirs} " in
11403     *" binutils "*) ;;
11404     *) ok=no ;;
11405   esac
11406
11407   if test $ok = yes; then
11408     # An in-tree tool is available and we can use it
11409     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11410     echo "$as_me:$LINENO: result: just compiled" >&5
11411 echo "${ECHO_T}just compiled" >&6
11412   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11413     # We already found the complete path
11414     ac_dir=`dirname $AR_FOR_TARGET`
11415     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11416 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11417   elif test "x$target" = "x$host"; then
11418     # We can use an host tool
11419     AR_FOR_TARGET='$(AR)'
11420     echo "$as_me:$LINENO: result: host tool" >&5
11421 echo "${ECHO_T}host tool" >&6
11422   else
11423     # We need a cross tool
11424     echo "$as_me:$LINENO: result: pre-installed" >&5
11425 echo "${ECHO_T}pre-installed" >&6
11426   fi
11427 fi
11428
11429 echo "$as_me:$LINENO: checking where to find the target as" >&5
11430 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11431 if test "x${build}" != "x${host}" ; then
11432   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11433     # We already found the complete path
11434     ac_dir=`dirname $AS_FOR_TARGET`
11435     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11436 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11437   else
11438     # Canadian cross, just use what we found
11439     echo "$as_me:$LINENO: result: pre-installed" >&5
11440 echo "${ECHO_T}pre-installed" >&6
11441   fi
11442 else
11443   ok=yes
11444   case " ${configdirs} " in
11445     *" gas "*) ;;
11446     *) ok=no ;;
11447   esac
11448
11449   if test $ok = yes; then
11450     # An in-tree tool is available and we can use it
11451     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11452     echo "$as_me:$LINENO: result: just compiled" >&5
11453 echo "${ECHO_T}just compiled" >&6
11454   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11455     # We already found the complete path
11456     ac_dir=`dirname $AS_FOR_TARGET`
11457     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11458 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11459   elif test "x$target" = "x$host"; then
11460     # We can use an host tool
11461     AS_FOR_TARGET='$(AS)'
11462     echo "$as_me:$LINENO: result: host tool" >&5
11463 echo "${ECHO_T}host tool" >&6
11464   else
11465     # We need a cross tool
11466     echo "$as_me:$LINENO: result: pre-installed" >&5
11467 echo "${ECHO_T}pre-installed" >&6
11468   fi
11469 fi
11470
11471 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11472 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11473 if test "x${build}" != "x${host}" ; then
11474   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11475     # We already found the complete path
11476     ac_dir=`dirname $CC_FOR_TARGET`
11477     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11478 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11479   else
11480     # Canadian cross, just use what we found
11481     echo "$as_me:$LINENO: result: pre-installed" >&5
11482 echo "${ECHO_T}pre-installed" >&6
11483   fi
11484 else
11485   ok=yes
11486   case " ${configdirs} " in
11487     *" gcc "*) ;;
11488     *) ok=no ;;
11489   esac
11490
11491   if test $ok = yes; then
11492     # An in-tree tool is available and we can use it
11493     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11494     echo "$as_me:$LINENO: result: just compiled" >&5
11495 echo "${ECHO_T}just compiled" >&6
11496   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11497     # We already found the complete path
11498     ac_dir=`dirname $CC_FOR_TARGET`
11499     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11500 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11501   elif test "x$target" = "x$host"; then
11502     # We can use an host tool
11503     CC_FOR_TARGET='$(CC)'
11504     echo "$as_me:$LINENO: result: host tool" >&5
11505 echo "${ECHO_T}host tool" >&6
11506   else
11507     # We need a cross tool
11508     echo "$as_me:$LINENO: result: pre-installed" >&5
11509 echo "${ECHO_T}pre-installed" >&6
11510   fi
11511 fi
11512
11513 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11514 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11515 if test "x${build}" != "x${host}" ; then
11516   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11517     # We already found the complete path
11518     ac_dir=`dirname $CXX_FOR_TARGET`
11519     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11520 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11521   else
11522     # Canadian cross, just use what we found
11523     echo "$as_me:$LINENO: result: pre-installed" >&5
11524 echo "${ECHO_T}pre-installed" >&6
11525   fi
11526 else
11527   ok=yes
11528   case " ${configdirs} " in
11529     *" gcc "*) ;;
11530     *) ok=no ;;
11531   esac
11532   case ,${enable_languages}, in
11533     *,c++,*) ;;
11534     *) ok=no ;;
11535   esac
11536   if test $ok = yes; then
11537     # An in-tree tool is available and we can use it
11538     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'
11539     echo "$as_me:$LINENO: result: just compiled" >&5
11540 echo "${ECHO_T}just compiled" >&6
11541   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11542     # We already found the complete path
11543     ac_dir=`dirname $CXX_FOR_TARGET`
11544     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11545 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11546   elif test "x$target" = "x$host"; then
11547     # We can use an host tool
11548     CXX_FOR_TARGET='$(CXX)'
11549     echo "$as_me:$LINENO: result: host tool" >&5
11550 echo "${ECHO_T}host tool" >&6
11551   else
11552     # We need a cross tool
11553     echo "$as_me:$LINENO: result: pre-installed" >&5
11554 echo "${ECHO_T}pre-installed" >&6
11555   fi
11556 fi
11557
11558 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11559 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11560 if test "x${build}" != "x${host}" ; then
11561   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11562     # We already found the complete path
11563     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11564     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11565 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11566   else
11567     # Canadian cross, just use what we found
11568     echo "$as_me:$LINENO: result: pre-installed" >&5
11569 echo "${ECHO_T}pre-installed" >&6
11570   fi
11571 else
11572   ok=yes
11573   case " ${configdirs} " in
11574     *" gcc "*) ;;
11575     *) ok=no ;;
11576   esac
11577   case ,${enable_languages}, in
11578     *,c++,*) ;;
11579     *) ok=no ;;
11580   esac
11581   if test $ok = yes; then
11582     # An in-tree tool is available and we can use it
11583     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'
11584     echo "$as_me:$LINENO: result: just compiled" >&5
11585 echo "${ECHO_T}just compiled" >&6
11586   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11587     # We already found the complete path
11588     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11589     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11590 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11591   elif test "x$target" = "x$host"; then
11592     # We can use an host tool
11593     RAW_CXX_FOR_TARGET='$(CXX)'
11594     echo "$as_me:$LINENO: result: host tool" >&5
11595 echo "${ECHO_T}host tool" >&6
11596   else
11597     # We need a cross tool
11598     echo "$as_me:$LINENO: result: pre-installed" >&5
11599 echo "${ECHO_T}pre-installed" >&6
11600   fi
11601 fi
11602
11603 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11604 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11605 if test "x${build}" != "x${host}" ; then
11606   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11607     # We already found the complete path
11608     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11609     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11610 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11611   else
11612     # Canadian cross, just use what we found
11613     echo "$as_me:$LINENO: result: pre-installed" >&5
11614 echo "${ECHO_T}pre-installed" >&6
11615   fi
11616 else
11617   ok=yes
11618   case " ${configdirs} " in
11619     *" binutils "*) ;;
11620     *) ok=no ;;
11621   esac
11622
11623   if test $ok = yes; then
11624     # An in-tree tool is available and we can use it
11625     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11626     echo "$as_me:$LINENO: result: just compiled" >&5
11627 echo "${ECHO_T}just compiled" >&6
11628   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11629     # We already found the complete path
11630     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11631     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11632 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11633   elif test "x$target" = "x$host"; then
11634     # We can use an host tool
11635     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11636     echo "$as_me:$LINENO: result: host tool" >&5
11637 echo "${ECHO_T}host tool" >&6
11638   else
11639     # We need a cross tool
11640     echo "$as_me:$LINENO: result: pre-installed" >&5
11641 echo "${ECHO_T}pre-installed" >&6
11642   fi
11643 fi
11644
11645 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11646 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11647 if test "x${build}" != "x${host}" ; then
11648   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11649     # We already found the complete path
11650     ac_dir=`dirname $GCC_FOR_TARGET`
11651     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11652 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11653   else
11654     # Canadian cross, just use what we found
11655     echo "$as_me:$LINENO: result: pre-installed" >&5
11656 echo "${ECHO_T}pre-installed" >&6
11657   fi
11658 else
11659   ok=yes
11660   case " ${configdirs} " in
11661     *" gcc "*) ;;
11662     *) ok=no ;;
11663   esac
11664
11665   if test $ok = yes; then
11666     # An in-tree tool is available and we can use it
11667     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11668     echo "$as_me:$LINENO: result: just compiled" >&5
11669 echo "${ECHO_T}just compiled" >&6
11670   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11671     # We already found the complete path
11672     ac_dir=`dirname $GCC_FOR_TARGET`
11673     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11674 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11675   elif test "x$target" = "x$host"; then
11676     # We can use an host tool
11677     GCC_FOR_TARGET='$()'
11678     echo "$as_me:$LINENO: result: host tool" >&5
11679 echo "${ECHO_T}host tool" >&6
11680   else
11681     # We need a cross tool
11682     echo "$as_me:$LINENO: result: pre-installed" >&5
11683 echo "${ECHO_T}pre-installed" >&6
11684   fi
11685 fi
11686
11687 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11688 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11689 if test "x${build}" != "x${host}" ; then
11690   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11691     # We already found the complete path
11692     ac_dir=`dirname $GCJ_FOR_TARGET`
11693     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11694 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11695   else
11696     # Canadian cross, just use what we found
11697     echo "$as_me:$LINENO: result: pre-installed" >&5
11698 echo "${ECHO_T}pre-installed" >&6
11699   fi
11700 else
11701   ok=yes
11702   case " ${configdirs} " in
11703     *" gcc "*) ;;
11704     *) ok=no ;;
11705   esac
11706   case ,${enable_languages}, in
11707     *,java,*) ;;
11708     *) ok=no ;;
11709   esac
11710   if test $ok = yes; then
11711     # An in-tree tool is available and we can use it
11712     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11713     echo "$as_me:$LINENO: result: just compiled" >&5
11714 echo "${ECHO_T}just compiled" >&6
11715   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11716     # We already found the complete path
11717     ac_dir=`dirname $GCJ_FOR_TARGET`
11718     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11719 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11720   elif test "x$target" = "x$host"; then
11721     # We can use an host tool
11722     GCJ_FOR_TARGET='$(GCJ)'
11723     echo "$as_me:$LINENO: result: host tool" >&5
11724 echo "${ECHO_T}host tool" >&6
11725   else
11726     # We need a cross tool
11727     echo "$as_me:$LINENO: result: pre-installed" >&5
11728 echo "${ECHO_T}pre-installed" >&6
11729   fi
11730 fi
11731
11732 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11733 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11734 if test "x${build}" != "x${host}" ; then
11735   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11736     # We already found the complete path
11737     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11738     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11739 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11740   else
11741     # Canadian cross, just use what we found
11742     echo "$as_me:$LINENO: result: pre-installed" >&5
11743 echo "${ECHO_T}pre-installed" >&6
11744   fi
11745 else
11746   ok=yes
11747   case " ${configdirs} " in
11748     *" gcc "*) ;;
11749     *) ok=no ;;
11750   esac
11751   case ,${enable_languages}, in
11752     *,fortran,*) ;;
11753     *) ok=no ;;
11754   esac
11755   if test $ok = yes; then
11756     # An in-tree tool is available and we can use it
11757     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11758     echo "$as_me:$LINENO: result: just compiled" >&5
11759 echo "${ECHO_T}just compiled" >&6
11760   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11761     # We already found the complete path
11762     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11763     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11764 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11765   elif test "x$target" = "x$host"; then
11766     # We can use an host tool
11767     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11768     echo "$as_me:$LINENO: result: host tool" >&5
11769 echo "${ECHO_T}host tool" >&6
11770   else
11771     # We need a cross tool
11772     echo "$as_me:$LINENO: result: pre-installed" >&5
11773 echo "${ECHO_T}pre-installed" >&6
11774   fi
11775 fi
11776
11777 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11778 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11779 if test "x${build}" != "x${host}" ; then
11780   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11781     # We already found the complete path
11782     ac_dir=`dirname $LD_FOR_TARGET`
11783     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11784 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11785   else
11786     # Canadian cross, just use what we found
11787     echo "$as_me:$LINENO: result: pre-installed" >&5
11788 echo "${ECHO_T}pre-installed" >&6
11789   fi
11790 else
11791   ok=yes
11792   case " ${configdirs} " in
11793     *" ld "*) ;;
11794     *) ok=no ;;
11795   esac
11796
11797   if test $ok = yes; then
11798     # An in-tree tool is available and we can use it
11799     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11800     echo "$as_me:$LINENO: result: just compiled" >&5
11801 echo "${ECHO_T}just compiled" >&6
11802   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11803     # We already found the complete path
11804     ac_dir=`dirname $LD_FOR_TARGET`
11805     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11806 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11807   elif test "x$target" = "x$host"; then
11808     # We can use an host tool
11809     LD_FOR_TARGET='$(LD)'
11810     echo "$as_me:$LINENO: result: host tool" >&5
11811 echo "${ECHO_T}host tool" >&6
11812   else
11813     # We need a cross tool
11814     echo "$as_me:$LINENO: result: pre-installed" >&5
11815 echo "${ECHO_T}pre-installed" >&6
11816   fi
11817 fi
11818
11819 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11820 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11821 if test "x${build}" != "x${host}" ; then
11822   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11823     # We already found the complete path
11824     ac_dir=`dirname $LIPO_FOR_TARGET`
11825     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11826 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11827   else
11828     # Canadian cross, just use what we found
11829     echo "$as_me:$LINENO: result: pre-installed" >&5
11830 echo "${ECHO_T}pre-installed" >&6
11831   fi
11832 else
11833   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11834     # We already found the complete path
11835     ac_dir=`dirname $LIPO_FOR_TARGET`
11836     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11837 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11838   elif test "x$target" = "x$host"; then
11839     # We can use an host tool
11840     LIPO_FOR_TARGET='$(LIPO)'
11841     echo "$as_me:$LINENO: result: host tool" >&5
11842 echo "${ECHO_T}host tool" >&6
11843   else
11844     # We need a cross tool
11845     echo "$as_me:$LINENO: result: pre-installed" >&5
11846 echo "${ECHO_T}pre-installed" >&6
11847   fi
11848 fi
11849
11850 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11851 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11852 if test "x${build}" != "x${host}" ; then
11853   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11854     # We already found the complete path
11855     ac_dir=`dirname $NM_FOR_TARGET`
11856     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11857 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11858   else
11859     # Canadian cross, just use what we found
11860     echo "$as_me:$LINENO: result: pre-installed" >&5
11861 echo "${ECHO_T}pre-installed" >&6
11862   fi
11863 else
11864   ok=yes
11865   case " ${configdirs} " in
11866     *" binutils "*) ;;
11867     *) ok=no ;;
11868   esac
11869
11870   if test $ok = yes; then
11871     # An in-tree tool is available and we can use it
11872     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11873     echo "$as_me:$LINENO: result: just compiled" >&5
11874 echo "${ECHO_T}just compiled" >&6
11875   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11876     # We already found the complete path
11877     ac_dir=`dirname $NM_FOR_TARGET`
11878     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11879 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11880   elif test "x$target" = "x$host"; then
11881     # We can use an host tool
11882     NM_FOR_TARGET='$(NM)'
11883     echo "$as_me:$LINENO: result: host tool" >&5
11884 echo "${ECHO_T}host tool" >&6
11885   else
11886     # We need a cross tool
11887     echo "$as_me:$LINENO: result: pre-installed" >&5
11888 echo "${ECHO_T}pre-installed" >&6
11889   fi
11890 fi
11891
11892 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11893 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11894 if test "x${build}" != "x${host}" ; then
11895   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11896     # We already found the complete path
11897     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11898     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11899 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11900   else
11901     # Canadian cross, just use what we found
11902     echo "$as_me:$LINENO: result: pre-installed" >&5
11903 echo "${ECHO_T}pre-installed" >&6
11904   fi
11905 else
11906   ok=yes
11907   case " ${configdirs} " in
11908     *" binutils "*) ;;
11909     *) ok=no ;;
11910   esac
11911
11912   if test $ok = yes; then
11913     # An in-tree tool is available and we can use it
11914     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11915     echo "$as_me:$LINENO: result: just compiled" >&5
11916 echo "${ECHO_T}just compiled" >&6
11917   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11918     # We already found the complete path
11919     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11920     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11921 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11922   elif test "x$target" = "x$host"; then
11923     # We can use an host tool
11924     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11925     echo "$as_me:$LINENO: result: host tool" >&5
11926 echo "${ECHO_T}host tool" >&6
11927   else
11928     # We need a cross tool
11929     echo "$as_me:$LINENO: result: pre-installed" >&5
11930 echo "${ECHO_T}pre-installed" >&6
11931   fi
11932 fi
11933
11934 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11935 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11936 if test "x${build}" != "x${host}" ; then
11937   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11938     # We already found the complete path
11939     ac_dir=`dirname $RANLIB_FOR_TARGET`
11940     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11941 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11942   else
11943     # Canadian cross, just use what we found
11944     echo "$as_me:$LINENO: result: pre-installed" >&5
11945 echo "${ECHO_T}pre-installed" >&6
11946   fi
11947 else
11948   ok=yes
11949   case " ${configdirs} " in
11950     *" binutils "*) ;;
11951     *) ok=no ;;
11952   esac
11953
11954   if test $ok = yes; then
11955     # An in-tree tool is available and we can use it
11956     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11957     echo "$as_me:$LINENO: result: just compiled" >&5
11958 echo "${ECHO_T}just compiled" >&6
11959   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11960     # We already found the complete path
11961     ac_dir=`dirname $RANLIB_FOR_TARGET`
11962     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11963 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11964   elif test "x$target" = "x$host"; then
11965     # We can use an host tool
11966     RANLIB_FOR_TARGET='$(RANLIB)'
11967     echo "$as_me:$LINENO: result: host tool" >&5
11968 echo "${ECHO_T}host tool" >&6
11969   else
11970     # We need a cross tool
11971     echo "$as_me:$LINENO: result: pre-installed" >&5
11972 echo "${ECHO_T}pre-installed" >&6
11973   fi
11974 fi
11975
11976 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11977 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11978 if test "x${build}" != "x${host}" ; then
11979   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11980     # We already found the complete path
11981     ac_dir=`dirname $STRIP_FOR_TARGET`
11982     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11983 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11984   else
11985     # Canadian cross, just use what we found
11986     echo "$as_me:$LINENO: result: pre-installed" >&5
11987 echo "${ECHO_T}pre-installed" >&6
11988   fi
11989 else
11990   ok=yes
11991   case " ${configdirs} " in
11992     *" binutils "*) ;;
11993     *) ok=no ;;
11994   esac
11995
11996   if test $ok = yes; then
11997     # An in-tree tool is available and we can use it
11998     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11999     echo "$as_me:$LINENO: result: just compiled" >&5
12000 echo "${ECHO_T}just compiled" >&6
12001   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12002     # We already found the complete path
12003     ac_dir=`dirname $STRIP_FOR_TARGET`
12004     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12005 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12006   elif test "x$target" = "x$host"; then
12007     # We can use an host tool
12008     STRIP_FOR_TARGET='$(STRIP)'
12009     echo "$as_me:$LINENO: result: host tool" >&5
12010 echo "${ECHO_T}host tool" >&6
12011   else
12012     # We need a cross tool
12013     echo "$as_me:$LINENO: result: pre-installed" >&5
12014 echo "${ECHO_T}pre-installed" >&6
12015   fi
12016 fi
12017
12018 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12019 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12020 if test "x${build}" != "x${host}" ; then
12021   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12022     # We already found the complete path
12023     ac_dir=`dirname $WINDRES_FOR_TARGET`
12024     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12025 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12026   else
12027     # Canadian cross, just use what we found
12028     echo "$as_me:$LINENO: result: pre-installed" >&5
12029 echo "${ECHO_T}pre-installed" >&6
12030   fi
12031 else
12032   ok=yes
12033   case " ${configdirs} " in
12034     *" binutils "*) ;;
12035     *) ok=no ;;
12036   esac
12037
12038   if test $ok = yes; then
12039     # An in-tree tool is available and we can use it
12040     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12041     echo "$as_me:$LINENO: result: just compiled" >&5
12042 echo "${ECHO_T}just compiled" >&6
12043   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12044     # We already found the complete path
12045     ac_dir=`dirname $WINDRES_FOR_TARGET`
12046     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12047 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12048   elif test "x$target" = "x$host"; then
12049     # We can use an host tool
12050     WINDRES_FOR_TARGET='$(WINDRES)'
12051     echo "$as_me:$LINENO: result: host tool" >&5
12052 echo "${ECHO_T}host tool" >&6
12053   else
12054     # We need a cross tool
12055     echo "$as_me:$LINENO: result: pre-installed" >&5
12056 echo "${ECHO_T}pre-installed" >&6
12057   fi
12058 fi
12059
12060 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12061 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12062 if test "x${build}" != "x${host}" ; then
12063   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12064     # We already found the complete path
12065     ac_dir=`dirname $WINDMC_FOR_TARGET`
12066     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12067 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12068   else
12069     # Canadian cross, just use what we found
12070     echo "$as_me:$LINENO: result: pre-installed" >&5
12071 echo "${ECHO_T}pre-installed" >&6
12072   fi
12073 else
12074   ok=yes
12075   case " ${configdirs} " in
12076     *" binutils "*) ;;
12077     *) ok=no ;;
12078   esac
12079
12080   if test $ok = yes; then
12081     # An in-tree tool is available and we can use it
12082     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12083     echo "$as_me:$LINENO: result: just compiled" >&5
12084 echo "${ECHO_T}just compiled" >&6
12085   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12086     # We already found the complete path
12087     ac_dir=`dirname $WINDMC_FOR_TARGET`
12088     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12089 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12090   elif test "x$target" = "x$host"; then
12091     # We can use an host tool
12092     WINDMC_FOR_TARGET='$(WINDMC)'
12093     echo "$as_me:$LINENO: result: host tool" >&5
12094 echo "${ECHO_T}host tool" >&6
12095   else
12096     # We need a cross tool
12097     echo "$as_me:$LINENO: result: pre-installed" >&5
12098 echo "${ECHO_T}pre-installed" >&6
12099   fi
12100 fi
12101
12102
12103
12104
12105
12106 # Certain tools may need extra flags.
12107 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12108 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12109 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12110
12111 # When building target libraries, except in a Canadian cross, we use
12112 # the same toolchain as the compiler we just built.
12113 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12114 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12115 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12116 if test $host = $build; then
12117   case " $configdirs " in
12118     *" gcc "*)
12119       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12120       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12121       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12122       ;;
12123   esac
12124 fi
12125
12126
12127
12128
12129
12130 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12131 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12132 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12133 if test "${enable_maintainer_mode+set}" = set; then
12134   enableval="$enable_maintainer_mode"
12135   USE_MAINTAINER_MODE=$enableval
12136 else
12137   USE_MAINTAINER_MODE=no
12138 fi;
12139 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12140 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12141
12142
12143 if test "$USE_MAINTAINER_MODE" = yes; then
12144   MAINTAINER_MODE_TRUE=
12145   MAINTAINER_MODE_FALSE='#'
12146 else
12147   MAINTAINER_MODE_TRUE='#'
12148   MAINTAINER_MODE_FALSE=
12149 fi
12150 MAINT=$MAINTAINER_MODE_TRUE
12151
12152 # ---------------------
12153 # GCC bootstrap support
12154 # ---------------------
12155
12156 # Stage specific cflags for build.
12157 stage1_cflags="-g"
12158 case $build in
12159   vax-*-*)
12160     case ${GCC} in
12161       yes) stage1_cflags="-g -Wa,-J" ;;
12162       *) stage1_cflags="-g -J" ;;
12163     esac ;;
12164 esac
12165
12166 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12167 if test "$GCC" = yes; then
12168   saved_CFLAGS="$CFLAGS"
12169
12170   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12171   CFLAGS="$CFLAGS -fkeep-inline-functions"
12172   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12173 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12174   cat >conftest.$ac_ext <<_ACEOF
12175 /* confdefs.h.  */
12176 _ACEOF
12177 cat confdefs.h >>conftest.$ac_ext
12178 cat >>conftest.$ac_ext <<_ACEOF
12179 /* end confdefs.h.  */
12180
12181 #if (__GNUC__ < 3) \
12182     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12183                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12184 #error http://gcc.gnu.org/PR29382
12185 #endif
12186
12187 int
12188 main ()
12189 {
12190
12191   ;
12192   return 0;
12193 }
12194 _ACEOF
12195 rm -f conftest.$ac_objext
12196 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12197   (eval $ac_compile) 2>conftest.er1
12198   ac_status=$?
12199   grep -v '^ *+' conftest.er1 >conftest.err
12200   rm -f conftest.er1
12201   cat conftest.err >&5
12202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12203   (exit $ac_status); } &&
12204          { ac_try='test -z "$ac_c_werror_flag"
12205                          || test ! -s conftest.err'
12206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12207   (eval $ac_try) 2>&5
12208   ac_status=$?
12209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12210   (exit $ac_status); }; } &&
12211          { ac_try='test -s conftest.$ac_objext'
12212   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12213   (eval $ac_try) 2>&5
12214   ac_status=$?
12215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12216   (exit $ac_status); }; }; then
12217   echo "$as_me:$LINENO: result: yes" >&5
12218 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12219 else
12220   echo "$as_me: failed program was:" >&5
12221 sed 's/^/| /' conftest.$ac_ext >&5
12222
12223 echo "$as_me:$LINENO: result: no" >&5
12224 echo "${ECHO_T}no" >&6
12225 fi
12226 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12227
12228   CFLAGS="$saved_CFLAGS"
12229 fi
12230
12231
12232
12233 # Enable --enable-checking in stage1 of the compiler.
12234 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12235 if test "${enable_stage1_checking+set}" = set; then
12236   enableval="$enable_stage1_checking"
12237   stage1_checking=--enable-checking=${enable_stage1_checking}
12238 else
12239   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12240   stage1_checking=--enable-checking=yes,types
12241 else
12242   stage1_checking=--enable-checking=$enable_checking,types
12243 fi
12244 fi;
12245
12246
12247 # Enable -Werror in bootstrap stage2 and later.
12248 # Check whether --enable-werror or --disable-werror was given.
12249 if test "${enable_werror+set}" = set; then
12250   enableval="$enable_werror"
12251
12252 else
12253   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12254   enable_werror=yes
12255 else
12256   enable_werror=no
12257 fi
12258 fi;
12259 case ${enable_werror} in
12260   yes) stage2_werror_flag="--enable-werror-always" ;;
12261   *) stage2_werror_flag="" ;;
12262 esac
12263
12264
12265 # Flags needed to enable html installing and building
12266
12267 # Check whether --with-datarootdir or --without-datarootdir was given.
12268 if test "${with_datarootdir+set}" = set; then
12269   withval="$with_datarootdir"
12270   datarootdir="\${prefix}/${withval}"
12271 else
12272   datarootdir="\${prefix}/share"
12273 fi;
12274
12275
12276 # Check whether --with-docdir or --without-docdir was given.
12277 if test "${with_docdir+set}" = set; then
12278   withval="$with_docdir"
12279   docdir="\${prefix}/${withval}"
12280 else
12281   docdir="\${datarootdir}/doc"
12282 fi;
12283
12284
12285 # Check whether --with-pdfdir or --without-pdfdir was given.
12286 if test "${with_pdfdir+set}" = set; then
12287   withval="$with_pdfdir"
12288   pdfdir="\${prefix}/${withval}"
12289 else
12290   pdfdir="\${docdir}"
12291 fi;
12292
12293
12294 # Check whether --with-htmldir or --without-htmldir was given.
12295 if test "${with_htmldir+set}" = set; then
12296   withval="$with_htmldir"
12297   htmldir="\${prefix}/${withval}"
12298 else
12299   htmldir="\${docdir}"
12300 fi;
12301
12302
12303
12304
12305
12306
12307           ac_config_files="$ac_config_files Makefile"
12308 cat >confcache <<\_ACEOF
12309 # This file is a shell script that caches the results of configure
12310 # tests run on this system so they can be shared between configure
12311 # scripts and configure runs, see configure's option --config-cache.
12312 # It is not useful on other systems.  If it contains results you don't
12313 # want to keep, you may remove or edit it.
12314 #
12315 # config.status only pays attention to the cache file if you give it
12316 # the --recheck option to rerun configure.
12317 #
12318 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12319 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12320 # following values.
12321
12322 _ACEOF
12323
12324 # The following way of writing the cache mishandles newlines in values,
12325 # but we know of no workaround that is simple, portable, and efficient.
12326 # So, don't put newlines in cache variables' values.
12327 # Ultrix sh set writes to stderr and can't be redirected directly,
12328 # and sets the high bit in the cache file unless we assign to the vars.
12329 {
12330   (set) 2>&1 |
12331     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12332     *ac_space=\ *)
12333       # `set' does not quote correctly, so add quotes (double-quote
12334       # substitution turns \\\\ into \\, and sed turns \\ into \).
12335       sed -n \
12336         "s/'/'\\\\''/g;
12337           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12338       ;;
12339     *)
12340       # `set' quotes correctly as required by POSIX, so do not add quotes.
12341       sed -n \
12342         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12343       ;;
12344     esac;
12345 } |
12346   sed '
12347      t clear
12348      : clear
12349      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12350      t end
12351      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12352      : end' >>confcache
12353 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12354   if test -w $cache_file; then
12355     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12356     cat confcache >$cache_file
12357   else
12358     echo "not updating unwritable cache $cache_file"
12359   fi
12360 fi
12361 rm -f confcache
12362
12363 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12364 # Let make expand exec_prefix.
12365 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12366
12367 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12368 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12369 # trailing colons and then remove the whole line if VPATH becomes empty
12370 # (actually we leave an empty line to preserve line numbers).
12371 if test "x$srcdir" = x.; then
12372   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12373 s/:*\$(srcdir):*/:/;
12374 s/:*\${srcdir}:*/:/;
12375 s/:*@srcdir@:*/:/;
12376 s/^\([^=]*=[     ]*\):*/\1/;
12377 s/:*$//;
12378 s/^[^=]*=[       ]*$//;
12379 }'
12380 fi
12381
12382 # Transform confdefs.h into DEFS.
12383 # Protect against shell expansion while executing Makefile rules.
12384 # Protect against Makefile macro expansion.
12385 #
12386 # If the first sed substitution is executed (which looks for macros that
12387 # take arguments), then we branch to the quote section.  Otherwise,
12388 # look for a macro that doesn't take arguments.
12389 cat >confdef2opt.sed <<\_ACEOF
12390 t clear
12391 : clear
12392 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12393 t quote
12394 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12395 t quote
12396 d
12397 : quote
12398 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12399 s,\[,\\&,g
12400 s,\],\\&,g
12401 s,\$,$$,g
12402 p
12403 _ACEOF
12404 # We use echo to avoid assuming a particular line-breaking character.
12405 # The extra dot is to prevent the shell from consuming trailing
12406 # line-breaks from the sub-command output.  A line-break within
12407 # single-quotes doesn't work because, if this script is created in a
12408 # platform that uses two characters for line-breaks (e.g., DOS), tr
12409 # would break.
12410 ac_LF_and_DOT=`echo; echo .`
12411 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12412 rm -f confdef2opt.sed
12413
12414
12415 ac_libobjs=
12416 ac_ltlibobjs=
12417 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12418   # 1. Remove the extension, and $U if already installed.
12419   ac_i=`echo "$ac_i" |
12420          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12421   # 2. Add them.
12422   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12423   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12424 done
12425 LIBOBJS=$ac_libobjs
12426
12427 LTLIBOBJS=$ac_ltlibobjs
12428
12429
12430
12431 : ${CONFIG_STATUS=./config.status}
12432 ac_clean_files_save=$ac_clean_files
12433 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12434 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12435 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12436 cat >$CONFIG_STATUS <<_ACEOF
12437 #! $SHELL
12438 # Generated by $as_me.
12439 # Run this file to recreate the current configuration.
12440 # Compiler output produced by configure, useful for debugging
12441 # configure, is in config.log if it exists.
12442
12443 debug=false
12444 ac_cs_recheck=false
12445 ac_cs_silent=false
12446 SHELL=\${CONFIG_SHELL-$SHELL}
12447 _ACEOF
12448
12449 cat >>$CONFIG_STATUS <<\_ACEOF
12450 ## --------------------- ##
12451 ## M4sh Initialization.  ##
12452 ## --------------------- ##
12453
12454 # Be Bourne compatible
12455 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12456   emulate sh
12457   NULLCMD=:
12458   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12459   # is contrary to our usage.  Disable this feature.
12460   alias -g '${1+"$@"}'='"$@"'
12461 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12462   set -o posix
12463 fi
12464 DUALCASE=1; export DUALCASE # for MKS sh
12465
12466 # Support unset when possible.
12467 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12468   as_unset=unset
12469 else
12470   as_unset=false
12471 fi
12472
12473
12474 # Work around bugs in pre-3.0 UWIN ksh.
12475 $as_unset ENV MAIL MAILPATH
12476 PS1='$ '
12477 PS2='> '
12478 PS4='+ '
12479
12480 # NLS nuisances.
12481 for as_var in \
12482   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12483   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12484   LC_TELEPHONE LC_TIME
12485 do
12486   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12487     eval $as_var=C; export $as_var
12488   else
12489     $as_unset $as_var
12490   fi
12491 done
12492
12493 # Required to use basename.
12494 if expr a : '\(a\)' >/dev/null 2>&1; then
12495   as_expr=expr
12496 else
12497   as_expr=false
12498 fi
12499
12500 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12501   as_basename=basename
12502 else
12503   as_basename=false
12504 fi
12505
12506
12507 # Name of the executable.
12508 as_me=`$as_basename "$0" ||
12509 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12510          X"$0" : 'X\(//\)$' \| \
12511          X"$0" : 'X\(/\)$' \| \
12512          .     : '\(.\)' 2>/dev/null ||
12513 echo X/"$0" |
12514     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12515           /^X\/\(\/\/\)$/{ s//\1/; q; }
12516           /^X\/\(\/\).*/{ s//\1/; q; }
12517           s/.*/./; q'`
12518
12519
12520 # PATH needs CR, and LINENO needs CR and PATH.
12521 # Avoid depending upon Character Ranges.
12522 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12523 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12524 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12525 as_cr_digits='0123456789'
12526 as_cr_alnum=$as_cr_Letters$as_cr_digits
12527
12528 # The user is always right.
12529 if test "${PATH_SEPARATOR+set}" != set; then
12530   echo "#! /bin/sh" >conf$$.sh
12531   echo  "exit 0"   >>conf$$.sh
12532   chmod +x conf$$.sh
12533   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12534     PATH_SEPARATOR=';'
12535   else
12536     PATH_SEPARATOR=:
12537   fi
12538   rm -f conf$$.sh
12539 fi
12540
12541
12542   as_lineno_1=$LINENO
12543   as_lineno_2=$LINENO
12544   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12545   test "x$as_lineno_1" != "x$as_lineno_2" &&
12546   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12547   # Find who we are.  Look in the path if we contain no path at all
12548   # relative or not.
12549   case $0 in
12550     *[\\/]* ) as_myself=$0 ;;
12551     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12552 for as_dir in $PATH
12553 do
12554   IFS=$as_save_IFS
12555   test -z "$as_dir" && as_dir=.
12556   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12557 done
12558
12559        ;;
12560   esac
12561   # We did not find ourselves, most probably we were run as `sh COMMAND'
12562   # in which case we are not to be found in the path.
12563   if test "x$as_myself" = x; then
12564     as_myself=$0
12565   fi
12566   if test ! -f "$as_myself"; then
12567     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12568 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12569    { (exit 1); exit 1; }; }
12570   fi
12571   case $CONFIG_SHELL in
12572   '')
12573     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12574 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12575 do
12576   IFS=$as_save_IFS
12577   test -z "$as_dir" && as_dir=.
12578   for as_base in sh bash ksh sh5; do
12579          case $as_dir in
12580          /*)
12581            if ("$as_dir/$as_base" -c '
12582   as_lineno_1=$LINENO
12583   as_lineno_2=$LINENO
12584   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12585   test "x$as_lineno_1" != "x$as_lineno_2" &&
12586   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12587              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12588              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12589              CONFIG_SHELL=$as_dir/$as_base
12590              export CONFIG_SHELL
12591              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12592            fi;;
12593          esac
12594        done
12595 done
12596 ;;
12597   esac
12598
12599   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12600   # uniformly replaced by the line number.  The first 'sed' inserts a
12601   # line-number line before each line; the second 'sed' does the real
12602   # work.  The second script uses 'N' to pair each line-number line
12603   # with the numbered line, and appends trailing '-' during
12604   # substitution so that $LINENO is not a special case at line end.
12605   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12606   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12607   sed '=' <$as_myself |
12608     sed '
12609       N
12610       s,$,-,
12611       : loop
12612       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12613       t loop
12614       s,-$,,
12615       s,^['$as_cr_digits']*\n,,
12616     ' >$as_me.lineno &&
12617   chmod +x $as_me.lineno ||
12618     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12619 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12620    { (exit 1); exit 1; }; }
12621
12622   # Don't try to exec as it changes $[0], causing all sort of problems
12623   # (the dirname of $[0] is not the place where we might find the
12624   # original and so on.  Autoconf is especially sensible to this).
12625   . ./$as_me.lineno
12626   # Exit status is that of the last command.
12627   exit
12628 }
12629
12630
12631 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12632   *c*,-n*) ECHO_N= ECHO_C='
12633 ' ECHO_T='      ' ;;
12634   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12635   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12636 esac
12637
12638 if expr a : '\(a\)' >/dev/null 2>&1; then
12639   as_expr=expr
12640 else
12641   as_expr=false
12642 fi
12643
12644 rm -f conf$$ conf$$.exe conf$$.file
12645 echo >conf$$.file
12646 if ln -s conf$$.file conf$$ 2>/dev/null; then
12647   # We could just check for DJGPP; but this test a) works b) is more generic
12648   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12649   if test -f conf$$.exe; then
12650     # Don't use ln at all; we don't have any links
12651     as_ln_s='cp -p'
12652   else
12653     as_ln_s='ln -s'
12654   fi
12655 elif ln conf$$.file conf$$ 2>/dev/null; then
12656   as_ln_s=ln
12657 else
12658   as_ln_s='cp -p'
12659 fi
12660 rm -f conf$$ conf$$.exe conf$$.file
12661
12662 if mkdir -p . 2>/dev/null; then
12663   as_mkdir_p=:
12664 else
12665   test -d ./-p && rmdir ./-p
12666   as_mkdir_p=false
12667 fi
12668
12669 as_executable_p="test -f"
12670
12671 # Sed expression to map a string onto a valid CPP name.
12672 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12673
12674 # Sed expression to map a string onto a valid variable name.
12675 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12676
12677
12678 # IFS
12679 # We need space, tab and new line, in precisely that order.
12680 as_nl='
12681 '
12682 IFS="   $as_nl"
12683
12684 # CDPATH.
12685 $as_unset CDPATH
12686
12687 exec 6>&1
12688
12689 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12690 # report actual input values of CONFIG_FILES etc. instead of their
12691 # values after options handling.  Logging --version etc. is OK.
12692 exec 5>>config.log
12693 {
12694   echo
12695   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12696 ## Running $as_me. ##
12697 _ASBOX
12698 } >&5
12699 cat >&5 <<_CSEOF
12700
12701 This file was extended by $as_me, which was
12702 generated by GNU Autoconf 2.59.  Invocation command line was
12703
12704   CONFIG_FILES    = $CONFIG_FILES
12705   CONFIG_HEADERS  = $CONFIG_HEADERS
12706   CONFIG_LINKS    = $CONFIG_LINKS
12707   CONFIG_COMMANDS = $CONFIG_COMMANDS
12708   $ $0 $@
12709
12710 _CSEOF
12711 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12712 echo >&5
12713 _ACEOF
12714
12715 # Files that config.status was made for.
12716 if test -n "$ac_config_files"; then
12717   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12718 fi
12719
12720 if test -n "$ac_config_headers"; then
12721   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12722 fi
12723
12724 if test -n "$ac_config_links"; then
12725   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12726 fi
12727
12728 if test -n "$ac_config_commands"; then
12729   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12730 fi
12731
12732 cat >>$CONFIG_STATUS <<\_ACEOF
12733
12734 ac_cs_usage="\
12735 \`$as_me' instantiates files from templates according to the
12736 current configuration.
12737
12738 Usage: $0 [OPTIONS] [FILE]...
12739
12740   -h, --help       print this help, then exit
12741   -V, --version    print version number, then exit
12742   -q, --quiet      do not print progress messages
12743   -d, --debug      don't remove temporary files
12744       --recheck    update $as_me by reconfiguring in the same conditions
12745   --file=FILE[:TEMPLATE]
12746                    instantiate the configuration file FILE
12747
12748 Configuration files:
12749 $config_files
12750
12751 Report bugs to <bug-autoconf@gnu.org>."
12752 _ACEOF
12753
12754 cat >>$CONFIG_STATUS <<_ACEOF
12755 ac_cs_version="\\
12756 config.status
12757 configured by $0, generated by GNU Autoconf 2.59,
12758   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12759
12760 Copyright (C) 2003 Free Software Foundation, Inc.
12761 This config.status script is free software; the Free Software Foundation
12762 gives unlimited permission to copy, distribute and modify it."
12763 srcdir=$srcdir
12764 INSTALL="$INSTALL"
12765 _ACEOF
12766
12767 cat >>$CONFIG_STATUS <<\_ACEOF
12768 # If no file are specified by the user, then we need to provide default
12769 # value.  By we need to know if files were specified by the user.
12770 ac_need_defaults=:
12771 while test $# != 0
12772 do
12773   case $1 in
12774   --*=*)
12775     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12776     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12777     ac_shift=:
12778     ;;
12779   -*)
12780     ac_option=$1
12781     ac_optarg=$2
12782     ac_shift=shift
12783     ;;
12784   *) # This is not an option, so the user has probably given explicit
12785      # arguments.
12786      ac_option=$1
12787      ac_need_defaults=false;;
12788   esac
12789
12790   case $ac_option in
12791   # Handling of the options.
12792 _ACEOF
12793 cat >>$CONFIG_STATUS <<\_ACEOF
12794   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12795     ac_cs_recheck=: ;;
12796   --version | --vers* | -V )
12797     echo "$ac_cs_version"; exit 0 ;;
12798   --he | --h)
12799     # Conflict between --help and --header
12800     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12801 Try \`$0 --help' for more information." >&5
12802 echo "$as_me: error: ambiguous option: $1
12803 Try \`$0 --help' for more information." >&2;}
12804    { (exit 1); exit 1; }; };;
12805   --help | --hel | -h )
12806     echo "$ac_cs_usage"; exit 0 ;;
12807   --debug | --d* | -d )
12808     debug=: ;;
12809   --file | --fil | --fi | --f )
12810     $ac_shift
12811     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12812     ac_need_defaults=false;;
12813   --header | --heade | --head | --hea )
12814     $ac_shift
12815     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12816     ac_need_defaults=false;;
12817   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12818   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12819     ac_cs_silent=: ;;
12820
12821   # This is an error.
12822   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12823 Try \`$0 --help' for more information." >&5
12824 echo "$as_me: error: unrecognized option: $1
12825 Try \`$0 --help' for more information." >&2;}
12826    { (exit 1); exit 1; }; } ;;
12827
12828   *) ac_config_targets="$ac_config_targets $1" ;;
12829
12830   esac
12831   shift
12832 done
12833
12834 ac_configure_extra_args=
12835
12836 if $ac_cs_silent; then
12837   exec 6>/dev/null
12838   ac_configure_extra_args="$ac_configure_extra_args --silent"
12839 fi
12840
12841 _ACEOF
12842 cat >>$CONFIG_STATUS <<_ACEOF
12843 if \$ac_cs_recheck; then
12844   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12845   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12846 fi
12847
12848 _ACEOF
12849
12850
12851
12852
12853
12854 cat >>$CONFIG_STATUS <<\_ACEOF
12855 for ac_config_target in $ac_config_targets
12856 do
12857   case "$ac_config_target" in
12858   # Handling of arguments.
12859   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12860   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12861 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12862    { (exit 1); exit 1; }; };;
12863   esac
12864 done
12865
12866 # If the user did not use the arguments to specify the items to instantiate,
12867 # then the envvar interface is used.  Set only those that are not.
12868 # We use the long form for the default assignment because of an extremely
12869 # bizarre bug on SunOS 4.1.3.
12870 if $ac_need_defaults; then
12871   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12872 fi
12873
12874 # Have a temporary directory for convenience.  Make it in the build tree
12875 # simply because there is no reason to put it here, and in addition,
12876 # creating and moving files from /tmp can sometimes cause problems.
12877 # Create a temporary directory, and hook for its removal unless debugging.
12878 $debug ||
12879 {
12880   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12881   trap '{ (exit 1); exit 1; }' 1 2 13 15
12882 }
12883
12884 # Create a (secure) tmp directory for tmp files.
12885
12886 {
12887   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12888   test -n "$tmp" && test -d "$tmp"
12889 }  ||
12890 {
12891   tmp=./confstat$$-$RANDOM
12892   (umask 077 && mkdir $tmp)
12893 } ||
12894 {
12895    echo "$me: cannot create a temporary directory in ." >&2
12896    { (exit 1); exit 1; }
12897 }
12898
12899 _ACEOF
12900
12901 cat >>$CONFIG_STATUS <<_ACEOF
12902
12903 #
12904 # CONFIG_FILES section.
12905 #
12906
12907 # No need to generate the scripts if there are no CONFIG_FILES.
12908 # This happens for instance when ./config.status config.h
12909 if test -n "\$CONFIG_FILES"; then
12910   # Protect against being on the right side of a sed subst in config.status.
12911   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12912    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12913 s,@SHELL@,$SHELL,;t t
12914 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12915 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12916 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12917 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12918 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12919 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12920 s,@exec_prefix@,$exec_prefix,;t t
12921 s,@prefix@,$prefix,;t t
12922 s,@program_transform_name@,$program_transform_name,;t t
12923 s,@bindir@,$bindir,;t t
12924 s,@sbindir@,$sbindir,;t t
12925 s,@libexecdir@,$libexecdir,;t t
12926 s,@datadir@,$datadir,;t t
12927 s,@sysconfdir@,$sysconfdir,;t t
12928 s,@sharedstatedir@,$sharedstatedir,;t t
12929 s,@localstatedir@,$localstatedir,;t t
12930 s,@libdir@,$libdir,;t t
12931 s,@includedir@,$includedir,;t t
12932 s,@oldincludedir@,$oldincludedir,;t t
12933 s,@infodir@,$infodir,;t t
12934 s,@mandir@,$mandir,;t t
12935 s,@build_alias@,$build_alias,;t t
12936 s,@host_alias@,$host_alias,;t t
12937 s,@target_alias@,$target_alias,;t t
12938 s,@DEFS@,$DEFS,;t t
12939 s,@ECHO_C@,$ECHO_C,;t t
12940 s,@ECHO_N@,$ECHO_N,;t t
12941 s,@ECHO_T@,$ECHO_T,;t t
12942 s,@LIBS@,$LIBS,;t t
12943 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12944 s,@build@,$build,;t t
12945 s,@build_cpu@,$build_cpu,;t t
12946 s,@build_vendor@,$build_vendor,;t t
12947 s,@build_os@,$build_os,;t t
12948 s,@build_noncanonical@,$build_noncanonical,;t t
12949 s,@host_noncanonical@,$host_noncanonical,;t t
12950 s,@target_noncanonical@,$target_noncanonical,;t t
12951 s,@host@,$host,;t t
12952 s,@host_cpu@,$host_cpu,;t t
12953 s,@host_vendor@,$host_vendor,;t t
12954 s,@host_os@,$host_os,;t t
12955 s,@target@,$target,;t t
12956 s,@target_cpu@,$target_cpu,;t t
12957 s,@target_vendor@,$target_vendor,;t t
12958 s,@target_os@,$target_os,;t t
12959 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12960 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12961 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12962 s,@LN@,$LN,;t t
12963 s,@LN_S@,$LN_S,;t t
12964 s,@build_libsubdir@,$build_libsubdir,;t t
12965 s,@build_subdir@,$build_subdir,;t t
12966 s,@host_subdir@,$host_subdir,;t t
12967 s,@target_subdir@,$target_subdir,;t t
12968 s,@CC@,$CC,;t t
12969 s,@CFLAGS@,$CFLAGS,;t t
12970 s,@LDFLAGS@,$LDFLAGS,;t t
12971 s,@CPPFLAGS@,$CPPFLAGS,;t t
12972 s,@ac_ct_CC@,$ac_ct_CC,;t t
12973 s,@EXEEXT@,$EXEEXT,;t t
12974 s,@OBJEXT@,$OBJEXT,;t t
12975 s,@CXX@,$CXX,;t t
12976 s,@CXXFLAGS@,$CXXFLAGS,;t t
12977 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12978 s,@GNATBIND@,$GNATBIND,;t t
12979 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12980 s,@GNATMAKE@,$GNATMAKE,;t t
12981 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12982 s,@do_compare@,$do_compare,;t t
12983 s,@gmplibs@,$gmplibs,;t t
12984 s,@gmpinc@,$gmpinc,;t t
12985 s,@stage1_languages@,$stage1_languages,;t t
12986 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12987 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12988 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12989 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12990 s,@CPPFLAGS_FOR_TARGET@,$CPPFLAGS_FOR_TARGET,;t t
12991 s,@LDFLAGS_FOR_TARGET@,$LDFLAGS_FOR_TARGET,;t t
12992 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12993 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
12994 s,@tooldir@,$tooldir,;t t
12995 s,@build_tooldir@,$build_tooldir,;t t
12996 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12997 s,@GDB_TK@,$GDB_TK,;t t
12998 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12999 s,@build_configargs@,$build_configargs,;t t
13000 s,@build_configdirs@,$build_configdirs,;t t
13001 s,@host_configargs@,$host_configargs,;t t
13002 s,@configdirs@,$configdirs,;t t
13003 s,@target_configargs@,$target_configargs,;t t
13004 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13005 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13006 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13007 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13008 s,@CPPFLAGS_FOR_BUILD@,$CPPFLAGS_FOR_BUILD,;t t
13009 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13010 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13011 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13012 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13013 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13014 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13015 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13016 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13017 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13018 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13019 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13020 s,@config_shell@,$config_shell,;t t
13021 s,@YACC@,$YACC,;t t
13022 s,@BISON@,$BISON,;t t
13023 s,@M4@,$M4,;t t
13024 s,@LEX@,$LEX,;t t
13025 s,@FLEX@,$FLEX,;t t
13026 s,@MAKEINFO@,$MAKEINFO,;t t
13027 s,@EXPECT@,$EXPECT,;t t
13028 s,@RUNTEST@,$RUNTEST,;t t
13029 s,@AR@,$AR,;t t
13030 s,@AS@,$AS,;t t
13031 s,@DLLTOOL@,$DLLTOOL,;t t
13032 s,@LD@,$LD,;t t
13033 s,@LIPO@,$LIPO,;t t
13034 s,@NM@,$NM,;t t
13035 s,@RANLIB@,$RANLIB,;t t
13036 s,@STRIP@,$STRIP,;t t
13037 s,@WINDRES@,$WINDRES,;t t
13038 s,@WINDMC@,$WINDMC,;t t
13039 s,@OBJCOPY@,$OBJCOPY,;t t
13040 s,@OBJDUMP@,$OBJDUMP,;t t
13041 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13042 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13043 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13044 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13045 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13046 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13047 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13048 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13049 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13050 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13051 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13052 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13053 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13054 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13055 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13056 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13057 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13058 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13059 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13060 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13061 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13062 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13063 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13064 s,@MAINT@,$MAINT,;t t
13065 s,@stage1_cflags@,$stage1_cflags,;t t
13066 s,@stage1_checking@,$stage1_checking,;t t
13067 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13068 s,@datarootdir@,$datarootdir,;t t
13069 s,@docdir@,$docdir,;t t
13070 s,@pdfdir@,$pdfdir,;t t
13071 s,@htmldir@,$htmldir,;t t
13072 s,@LIBOBJS@,$LIBOBJS,;t t
13073 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13074 /@serialization_dependencies@/r $serialization_dependencies
13075 s,@serialization_dependencies@,,;t t
13076 /@host_makefile_frag@/r $host_makefile_frag
13077 s,@host_makefile_frag@,,;t t
13078 /@target_makefile_frag@/r $target_makefile_frag
13079 s,@target_makefile_frag@,,;t t
13080 /@alphaieee_frag@/r $alphaieee_frag
13081 s,@alphaieee_frag@,,;t t
13082 /@ospace_frag@/r $ospace_frag
13083 s,@ospace_frag@,,;t t
13084 CEOF
13085
13086 _ACEOF
13087
13088   cat >>$CONFIG_STATUS <<\_ACEOF
13089   # Split the substitutions into bite-sized pieces for seds with
13090   # small command number limits, like on Digital OSF/1 and HP-UX.
13091   ac_max_sed_lines=48
13092   ac_sed_frag=1 # Number of current file.
13093   ac_beg=1 # First line for current file.
13094   ac_end=$ac_max_sed_lines # Line after last line for current file.
13095   ac_more_lines=:
13096   ac_sed_cmds=
13097   while $ac_more_lines; do
13098     if test $ac_beg -gt 1; then
13099       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13100     else
13101       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13102     fi
13103     if test ! -s $tmp/subs.frag; then
13104       ac_more_lines=false
13105     else
13106       # The purpose of the label and of the branching condition is to
13107       # speed up the sed processing (if there are no `@' at all, there
13108       # is no need to browse any of the substitutions).
13109       # These are the two extra sed commands mentioned above.
13110       (echo ':t
13111   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13112       if test -z "$ac_sed_cmds"; then
13113         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13114       else
13115         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13116       fi
13117       ac_sed_frag=`expr $ac_sed_frag + 1`
13118       ac_beg=$ac_end
13119       ac_end=`expr $ac_end + $ac_max_sed_lines`
13120     fi
13121   done
13122   if test -z "$ac_sed_cmds"; then
13123     ac_sed_cmds=cat
13124   fi
13125 fi # test -n "$CONFIG_FILES"
13126
13127 _ACEOF
13128 cat >>$CONFIG_STATUS <<\_ACEOF
13129 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13130   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13131   case $ac_file in
13132   - | *:- | *:-:* ) # input from stdin
13133         cat >$tmp/stdin
13134         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13135         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13136   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13137         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13138   * )   ac_file_in=$ac_file.in ;;
13139   esac
13140
13141   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13142   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13143 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13144          X"$ac_file" : 'X\(//\)[^/]' \| \
13145          X"$ac_file" : 'X\(//\)$' \| \
13146          X"$ac_file" : 'X\(/\)' \| \
13147          .     : '\(.\)' 2>/dev/null ||
13148 echo X"$ac_file" |
13149     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13150           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13151           /^X\(\/\/\)$/{ s//\1/; q; }
13152           /^X\(\/\).*/{ s//\1/; q; }
13153           s/.*/./; q'`
13154   { if $as_mkdir_p; then
13155     mkdir -p "$ac_dir"
13156   else
13157     as_dir="$ac_dir"
13158     as_dirs=
13159     while test ! -d "$as_dir"; do
13160       as_dirs="$as_dir $as_dirs"
13161       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13162 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13163          X"$as_dir" : 'X\(//\)[^/]' \| \
13164          X"$as_dir" : 'X\(//\)$' \| \
13165          X"$as_dir" : 'X\(/\)' \| \
13166          .     : '\(.\)' 2>/dev/null ||
13167 echo X"$as_dir" |
13168     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13169           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13170           /^X\(\/\/\)$/{ s//\1/; q; }
13171           /^X\(\/\).*/{ s//\1/; q; }
13172           s/.*/./; q'`
13173     done
13174     test ! -n "$as_dirs" || mkdir $as_dirs
13175   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13176 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13177    { (exit 1); exit 1; }; }; }
13178
13179   ac_builddir=.
13180
13181 if test "$ac_dir" != .; then
13182   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13183   # A "../" for each directory in $ac_dir_suffix.
13184   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13185 else
13186   ac_dir_suffix= ac_top_builddir=
13187 fi
13188
13189 case $srcdir in
13190   .)  # No --srcdir option.  We are building in place.
13191     ac_srcdir=.
13192     if test -z "$ac_top_builddir"; then
13193        ac_top_srcdir=.
13194     else
13195        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13196     fi ;;
13197   [\\/]* | ?:[\\/]* )  # Absolute path.
13198     ac_srcdir=$srcdir$ac_dir_suffix;
13199     ac_top_srcdir=$srcdir ;;
13200   *) # Relative path.
13201     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13202     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13203 esac
13204
13205 # Do not use `cd foo && pwd` to compute absolute paths, because
13206 # the directories may not exist.
13207 case `pwd` in
13208 .) ac_abs_builddir="$ac_dir";;
13209 *)
13210   case "$ac_dir" in
13211   .) ac_abs_builddir=`pwd`;;
13212   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13213   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13214   esac;;
13215 esac
13216 case $ac_abs_builddir in
13217 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13218 *)
13219   case ${ac_top_builddir}. in
13220   .) ac_abs_top_builddir=$ac_abs_builddir;;
13221   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13222   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13223   esac;;
13224 esac
13225 case $ac_abs_builddir in
13226 .) ac_abs_srcdir=$ac_srcdir;;
13227 *)
13228   case $ac_srcdir in
13229   .) ac_abs_srcdir=$ac_abs_builddir;;
13230   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13231   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13232   esac;;
13233 esac
13234 case $ac_abs_builddir in
13235 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13236 *)
13237   case $ac_top_srcdir in
13238   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13239   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13240   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13241   esac;;
13242 esac
13243
13244
13245   case $INSTALL in
13246   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13247   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13248   esac
13249
13250   if test x"$ac_file" != x-; then
13251     { echo "$as_me:$LINENO: creating $ac_file" >&5
13252 echo "$as_me: creating $ac_file" >&6;}
13253     rm -f "$ac_file"
13254   fi
13255   # Let's still pretend it is `configure' which instantiates (i.e., don't
13256   # use $as_me), people would be surprised to read:
13257   #    /* config.h.  Generated by config.status.  */
13258   if test x"$ac_file" = x-; then
13259     configure_input=
13260   else
13261     configure_input="$ac_file.  "
13262   fi
13263   configure_input=$configure_input"Generated from `echo $ac_file_in |
13264                                      sed 's,.*/,,'` by configure."
13265
13266   # First look for the input files in the build tree, otherwise in the
13267   # src tree.
13268   ac_file_inputs=`IFS=:
13269     for f in $ac_file_in; do
13270       case $f in
13271       -) echo $tmp/stdin ;;
13272       [\\/$]*)
13273          # Absolute (can't be DOS-style, as IFS=:)
13274          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13275 echo "$as_me: error: cannot find input file: $f" >&2;}
13276    { (exit 1); exit 1; }; }
13277          echo "$f";;
13278       *) # Relative
13279          if test -f "$f"; then
13280            # Build tree
13281            echo "$f"
13282          elif test -f "$srcdir/$f"; then
13283            # Source tree
13284            echo "$srcdir/$f"
13285          else
13286            # /dev/null tree
13287            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13288 echo "$as_me: error: cannot find input file: $f" >&2;}
13289    { (exit 1); exit 1; }; }
13290          fi;;
13291       esac
13292     done` || { (exit 1); exit 1; }
13293 _ACEOF
13294 cat >>$CONFIG_STATUS <<_ACEOF
13295   sed "$ac_vpsub
13296 $extrasub
13297 _ACEOF
13298 cat >>$CONFIG_STATUS <<\_ACEOF
13299 :t
13300 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13301 s,@configure_input@,$configure_input,;t t
13302 s,@srcdir@,$ac_srcdir,;t t
13303 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13304 s,@top_srcdir@,$ac_top_srcdir,;t t
13305 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13306 s,@builddir@,$ac_builddir,;t t
13307 s,@abs_builddir@,$ac_abs_builddir,;t t
13308 s,@top_builddir@,$ac_top_builddir,;t t
13309 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13310 s,@INSTALL@,$ac_INSTALL,;t t
13311 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13312   rm -f $tmp/stdin
13313   if test x"$ac_file" != x-; then
13314     mv $tmp/out $ac_file
13315   else
13316     cat $tmp/out
13317     rm -f $tmp/out
13318   fi
13319
13320 done
13321 _ACEOF
13322
13323 cat >>$CONFIG_STATUS <<\_ACEOF
13324
13325 { (exit 0); exit 0; }
13326 _ACEOF
13327 chmod +x $CONFIG_STATUS
13328 ac_clean_files=$ac_clean_files_save
13329
13330
13331 # configure is writing to config.log, and then calls config.status.
13332 # config.status does its own redirection, appending to config.log.
13333 # Unfortunately, on DOS this fails, as config.log is still kept open
13334 # by configure, so config.status won't be able to write to it; its
13335 # output is simply discarded.  So we exec the FD to /dev/null,
13336 # effectively closing config.log, so it can be properly (re)opened and
13337 # appended to by config.status.  When coming back to configure, we
13338 # need to make the FD available again.
13339 if test "$no_create" != yes; then
13340   ac_cs_success=:
13341   ac_config_status_args=
13342   test "$silent" = yes &&
13343     ac_config_status_args="$ac_config_status_args --quiet"
13344   exec 5>/dev/null
13345   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13346   exec 5>>config.log
13347   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13348   # would make configure fail if this is the last instruction.
13349   $ac_cs_success || { (exit 1); exit 1; }
13350 fi
13351