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 RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --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 bfd binutils ld gas opcodes 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     skipdirs="target-libssp"
2647     ;;
2648   v810-*-*)
2649     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2650     ;;
2651   v850-*-*)
2652     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2653     ;;
2654   v850e-*-*)
2655     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2656     ;;
2657   v850ea-*-*)
2658     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2659     ;;
2660   vax-*-vms)
2661     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2662     ;;
2663   vax-*-*)
2664     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2665     ;;
2666   xtensa*-*-*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     ;;
2669   ip2k-*-*)
2670     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2671     ;;
2672   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2673     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2674     ;;
2675   *-*-lynxos*)
2676     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2677     ;;
2678   *-*-*)
2679     noconfigdirs="$noconfigdirs ${libgcj}"
2680     ;;
2681 esac
2682
2683 # If we aren't building newlib, then don't build libgloss, since libgloss
2684 # depends upon some newlib header files.
2685 case "${noconfigdirs}" in
2686   *target-libgloss*) ;;
2687   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2688 esac
2689
2690 # Work in distributions that contain no compiler tools, like Autoconf.
2691 tentative_cc=""
2692 host_makefile_frag=/dev/null
2693 if test -d ${srcdir}/config ; then
2694 case "${host}" in
2695   m68k-hp-hpux*)
2696     # Avoid "too much defining" errors from HPUX compiler.
2697     tentative_cc="cc -Wp,-H256000"
2698     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2699     # If it's HP/UX ar, this should be harmless.
2700     RANLIB="ar ts"
2701     ;;
2702   m68k-apollo-sysv*)
2703     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2704     ;;
2705   m68k-apollo-bsd*)
2706     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2707     # chokes on bfd, the compiler won't let you assign integers to enums, and
2708     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2709     # the apollo compiler" (the preferred version of GCC could be called cc,
2710     # or whatever), but I'm not sure leaving CC as cc is any better...
2711     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2712     # Used to have BISON=yacc.
2713     tentative_cc=gcc
2714     ;;
2715   m88k-dg-dgux*)
2716     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2717     ;;
2718   m88k-harris-cxux*)
2719     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2720     tentative_cc="cc -Xa"
2721     host_makefile_frag="config/mh-cxux"
2722     ;;
2723   m88k-motorola-sysv*)
2724     ;;
2725   mips*-dec-ultrix*)
2726     tentative_cc="cc -Wf,-XNg1000"
2727     host_makefile_frag="config/mh-decstation"
2728     ;;
2729   mips*-nec-sysv4*)
2730     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2731     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2732     host_makefile_frag="config/mh-necv4"
2733     ;;
2734   mips*-sgi-irix4*)
2735     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2736     # environment.  Also bump switch table size so that cp-parse will
2737     # compile.  Bump string length limit so linker builds.
2738     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2739     ;;
2740   mips*-*-sysv4*)
2741     host_makefile_frag="config/mh-sysv4"
2742     ;;
2743   mips*-*-sysv*)
2744     # This is for a MIPS running RISC/os 4.52C.
2745
2746     # This is needed for GDB, but needs to be in the top-level make because
2747     # if a library is compiled with the bsd headers and gets linked with the
2748     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2749     # a different size).
2750     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2751     # known except to select the sysv environment.  Could we use /proc instead?
2752     # These "sysv environments" and "bsd environments" often end up being a pain.
2753     #
2754     # This is not part of CFLAGS because perhaps not all C compilers have this
2755     # option.
2756     tentative_cc="cc -systype sysv"
2757     ;;
2758   i370-ibm-opened*)
2759     tentative_cc="c89"
2760     ;;
2761   i[3456789]86-*-sysv5*)
2762     host_makefile_frag="config/mh-sysv5"
2763     ;;
2764   i[3456789]86-*-dgux*)
2765     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2766     host_makefile_frag="config/mh-dgux386"
2767     ;;
2768   i[3456789]86-ncr-sysv4.3*)
2769     # The MetaWare compiler will generate a copyright message unless you
2770     # turn it off by adding the -Hnocopyr flag.
2771     tentative_cc="cc -Hnocopyr"
2772     ;;
2773   i[3456789]86-ncr-sysv4*)
2774     # for an NCR 3000 (i486/SVR4) system.
2775     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2776     # This compiler not only emits obnoxious copyright messages every time
2777     # you run it, but it chokes and dies on a whole bunch of GNU source
2778     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2779     tentative_cc="/usr/ccs/ATT/cc"
2780     host_makefile_frag="config/mh-ncr3000"
2781     ;;
2782   i[3456789]86-*-sco3.2v5*)
2783     ;;
2784   i[3456789]86-*-sco*)
2785     # The native C compiler botches some simple uses of const.  Unfortunately,
2786     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2787     tentative_cc="cc -Dconst="
2788     host_makefile_frag="config/mh-sco"
2789     ;;
2790   i[3456789]86-*-udk*)
2791     host_makefile_frag="config/mh-sysv5"
2792     ;;
2793   i[3456789]86-*-solaris2*)
2794     host_makefile_frag="config/mh-sysv4"
2795     ;;
2796   i[3456789]86-*-msdosdjgpp*)
2797     host_makefile_frag="config/mh-djgpp"
2798     ;;
2799   *-cygwin*)
2800
2801 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2802 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2803 echo a >cygwin-cat-check
2804 if test `cat cygwin-cat-check` == a ; then
2805   rm cygwin-cat-check
2806   echo "$as_me:$LINENO: result: yes" >&5
2807 echo "${ECHO_T}yes" >&6
2808 else
2809   rm cygwin-cat-check
2810   echo "$as_me:$LINENO: result: no" >&5
2811 echo "${ECHO_T}no" >&6
2812   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2813   Please either mount the build directory in binary mode or run the following
2814   commands before running any configure script:
2815 set -o igncr
2816 export SHELLOPTS
2817   " >&5
2818 echo "$as_me: error: The cat command does not ignore carriage return characters.
2819   Please either mount the build directory in binary mode or run the following
2820   commands before running any configure script:
2821 set -o igncr
2822 export SHELLOPTS
2823   " >&2;}
2824    { (exit 1); exit 1; }; }
2825 fi
2826
2827     host_makefile_frag="config/mh-cygwin"
2828     ;;
2829   *-mingw*)
2830     host_makefile_frag="config/mh-mingw"
2831     ;;
2832   *-interix*)
2833     host_makefile_frag="config/mh-interix"
2834     ;;
2835   vax-*-ultrix2*)
2836     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2837     tentative_cc=gcc
2838     ;;
2839   *-*-solaris2*)
2840     host_makefile_frag="config/mh-solaris"
2841     ;;
2842   m68k-sun-sunos*)
2843     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2844     # without overflowing the jump tables (-J says to use a 32 bit table)
2845     tentative_cc="cc -J"
2846     ;;
2847   hppa*-hp-hpux10*)
2848     tentative_cc="cc -Wp,-H256000"
2849     host_makefile_frag="config/mh-pa-hpux10"
2850     ;;
2851   hppa*-hp-hpux* | hppa*-*-hiux*)
2852     tentative_cc="cc -Wp,-H256000"
2853     host_makefile_frag="config/mh-pa"
2854     ;;
2855   hppa*-*)
2856     host_makefile_frag="config/mh-pa"
2857     ;;
2858   *-hp-hpux* | *-*-hiux*)
2859     tentative_cc="cc -Wp,-H256000"
2860     ;;
2861   rs6000-*-lynxos*)
2862     # /bin/cc is less than useful for our purposes.  Always use GCC
2863     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2864     host_makefile_frag="config/mh-lynxrs6k"
2865     ;;
2866   powerpc-*-darwin*)
2867     host_makefile_frag="config/mh-ppc-darwin"
2868     ;;
2869   powerpc-*-aix*)
2870     host_makefile_frag="config/mh-ppc-aix"
2871     ;;
2872   rs6000-*-aix*)
2873     host_makefile_frag="config/mh-ppc-aix"
2874     ;;
2875   *-*-lynxos*)
2876     # /bin/cc is less than useful for our purposes.  Always use GCC
2877     tentative_cc="/bin/gcc"
2878     ;;
2879   *-*-sysv4*)
2880     host_makefile_frag="config/mh-sysv4"
2881     ;;
2882   # This is placed last to prevent interfering with the cases above.
2883   i[3456789]86-*-*)
2884     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2885     host_makefile_frag="config/mh-x86omitfp"
2886     ;;
2887 esac
2888 fi
2889
2890 # If we aren't going to be using gcc, see if we can extract a definition
2891 # of CC from the fragment.
2892 # Actually, use the 'pre-extracted' version above.
2893 if test -z "${CC}" && test "${build}" = "${host}" ; then
2894   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2895   found=
2896   for dir in $PATH; do
2897     test -z "$dir" && dir=.
2898     if test -f $dir/gcc; then
2899       found=yes
2900       break
2901     fi
2902   done
2903   IFS="$save_ifs"
2904   if test -z "${found}" && test -n "${tentative_cc}" ; then
2905     CC=$tentative_cc
2906   fi
2907 fi
2908
2909 if test "${build}" != "${host}" ; then
2910   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2911   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2912   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2913   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2914   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2915   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2916   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2917   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2918   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2919   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2920   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2921   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2922 else
2923   AR_FOR_BUILD="\$(AR)"
2924   AS_FOR_BUILD="\$(AS)"
2925   CC_FOR_BUILD="\$(CC)"
2926   CXX_FOR_BUILD="\$(CXX)"
2927   GCJ_FOR_BUILD="\$(GCJ)"
2928   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2929   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2930   LD_FOR_BUILD="\$(LD)"
2931   NM_FOR_BUILD="\$(NM)"
2932   RANLIB_FOR_BUILD="\$(RANLIB)"
2933   WINDRES_FOR_BUILD="\$(WINDRES)"
2934   WINDMC_FOR_BUILD="\$(WINDMC)"
2935 fi
2936
2937 ac_ext=c
2938 ac_cpp='$CPP $CPPFLAGS'
2939 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2940 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2941 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2942 if test -n "$ac_tool_prefix"; then
2943   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2944 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2945 echo "$as_me:$LINENO: checking for $ac_word" >&5
2946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2947 if test "${ac_cv_prog_CC+set}" = set; then
2948   echo $ECHO_N "(cached) $ECHO_C" >&6
2949 else
2950   if test -n "$CC"; then
2951   ac_cv_prog_CC="$CC" # Let the user override the test.
2952 else
2953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2954 for as_dir in $PATH
2955 do
2956   IFS=$as_save_IFS
2957   test -z "$as_dir" && as_dir=.
2958   for ac_exec_ext in '' $ac_executable_extensions; do
2959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2960     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2962     break 2
2963   fi
2964 done
2965 done
2966
2967 fi
2968 fi
2969 CC=$ac_cv_prog_CC
2970 if test -n "$CC"; then
2971   echo "$as_me:$LINENO: result: $CC" >&5
2972 echo "${ECHO_T}$CC" >&6
2973 else
2974   echo "$as_me:$LINENO: result: no" >&5
2975 echo "${ECHO_T}no" >&6
2976 fi
2977
2978 fi
2979 if test -z "$ac_cv_prog_CC"; then
2980   ac_ct_CC=$CC
2981   # Extract the first word of "gcc", so it can be a program name with args.
2982 set dummy gcc; ac_word=$2
2983 echo "$as_me:$LINENO: checking for $ac_word" >&5
2984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2985 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2986   echo $ECHO_N "(cached) $ECHO_C" >&6
2987 else
2988   if test -n "$ac_ct_CC"; then
2989   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2990 else
2991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2992 for as_dir in $PATH
2993 do
2994   IFS=$as_save_IFS
2995   test -z "$as_dir" && as_dir=.
2996   for ac_exec_ext in '' $ac_executable_extensions; do
2997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2998     ac_cv_prog_ac_ct_CC="gcc"
2999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3000     break 2
3001   fi
3002 done
3003 done
3004
3005 fi
3006 fi
3007 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3008 if test -n "$ac_ct_CC"; then
3009   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3010 echo "${ECHO_T}$ac_ct_CC" >&6
3011 else
3012   echo "$as_me:$LINENO: result: no" >&5
3013 echo "${ECHO_T}no" >&6
3014 fi
3015
3016   CC=$ac_ct_CC
3017 else
3018   CC="$ac_cv_prog_CC"
3019 fi
3020
3021 if test -z "$CC"; then
3022   if test -n "$ac_tool_prefix"; then
3023   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3024 set dummy ${ac_tool_prefix}cc; ac_word=$2
3025 echo "$as_me:$LINENO: checking for $ac_word" >&5
3026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3027 if test "${ac_cv_prog_CC+set}" = set; then
3028   echo $ECHO_N "(cached) $ECHO_C" >&6
3029 else
3030   if test -n "$CC"; then
3031   ac_cv_prog_CC="$CC" # Let the user override the test.
3032 else
3033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3034 for as_dir in $PATH
3035 do
3036   IFS=$as_save_IFS
3037   test -z "$as_dir" && as_dir=.
3038   for ac_exec_ext in '' $ac_executable_extensions; do
3039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3040     ac_cv_prog_CC="${ac_tool_prefix}cc"
3041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3042     break 2
3043   fi
3044 done
3045 done
3046
3047 fi
3048 fi
3049 CC=$ac_cv_prog_CC
3050 if test -n "$CC"; then
3051   echo "$as_me:$LINENO: result: $CC" >&5
3052 echo "${ECHO_T}$CC" >&6
3053 else
3054   echo "$as_me:$LINENO: result: no" >&5
3055 echo "${ECHO_T}no" >&6
3056 fi
3057
3058 fi
3059 if test -z "$ac_cv_prog_CC"; then
3060   ac_ct_CC=$CC
3061   # Extract the first word of "cc", so it can be a program name with args.
3062 set dummy cc; ac_word=$2
3063 echo "$as_me:$LINENO: checking for $ac_word" >&5
3064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3065 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3066   echo $ECHO_N "(cached) $ECHO_C" >&6
3067 else
3068   if test -n "$ac_ct_CC"; then
3069   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3070 else
3071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3072 for as_dir in $PATH
3073 do
3074   IFS=$as_save_IFS
3075   test -z "$as_dir" && as_dir=.
3076   for ac_exec_ext in '' $ac_executable_extensions; do
3077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3078     ac_cv_prog_ac_ct_CC="cc"
3079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3080     break 2
3081   fi
3082 done
3083 done
3084
3085 fi
3086 fi
3087 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3088 if test -n "$ac_ct_CC"; then
3089   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3090 echo "${ECHO_T}$ac_ct_CC" >&6
3091 else
3092   echo "$as_me:$LINENO: result: no" >&5
3093 echo "${ECHO_T}no" >&6
3094 fi
3095
3096   CC=$ac_ct_CC
3097 else
3098   CC="$ac_cv_prog_CC"
3099 fi
3100
3101 fi
3102 if test -z "$CC"; then
3103   # Extract the first word of "cc", so it can be a program name with args.
3104 set dummy cc; ac_word=$2
3105 echo "$as_me:$LINENO: checking for $ac_word" >&5
3106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3107 if test "${ac_cv_prog_CC+set}" = set; then
3108   echo $ECHO_N "(cached) $ECHO_C" >&6
3109 else
3110   if test -n "$CC"; then
3111   ac_cv_prog_CC="$CC" # Let the user override the test.
3112 else
3113   ac_prog_rejected=no
3114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3115 for as_dir in $PATH
3116 do
3117   IFS=$as_save_IFS
3118   test -z "$as_dir" && as_dir=.
3119   for ac_exec_ext in '' $ac_executable_extensions; do
3120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3121     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3122        ac_prog_rejected=yes
3123        continue
3124      fi
3125     ac_cv_prog_CC="cc"
3126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3127     break 2
3128   fi
3129 done
3130 done
3131
3132 if test $ac_prog_rejected = yes; then
3133   # We found a bogon in the path, so make sure we never use it.
3134   set dummy $ac_cv_prog_CC
3135   shift
3136   if test $# != 0; then
3137     # We chose a different compiler from the bogus one.
3138     # However, it has the same basename, so the bogon will be chosen
3139     # first if we set CC to just the basename; use the full file name.
3140     shift
3141     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3142   fi
3143 fi
3144 fi
3145 fi
3146 CC=$ac_cv_prog_CC
3147 if test -n "$CC"; then
3148   echo "$as_me:$LINENO: result: $CC" >&5
3149 echo "${ECHO_T}$CC" >&6
3150 else
3151   echo "$as_me:$LINENO: result: no" >&5
3152 echo "${ECHO_T}no" >&6
3153 fi
3154
3155 fi
3156 if test -z "$CC"; then
3157   if test -n "$ac_tool_prefix"; then
3158   for ac_prog in cl
3159   do
3160     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3161 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3162 echo "$as_me:$LINENO: checking for $ac_word" >&5
3163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3164 if test "${ac_cv_prog_CC+set}" = set; then
3165   echo $ECHO_N "(cached) $ECHO_C" >&6
3166 else
3167   if test -n "$CC"; then
3168   ac_cv_prog_CC="$CC" # Let the user override the test.
3169 else
3170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3171 for as_dir in $PATH
3172 do
3173   IFS=$as_save_IFS
3174   test -z "$as_dir" && as_dir=.
3175   for ac_exec_ext in '' $ac_executable_extensions; do
3176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3177     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3179     break 2
3180   fi
3181 done
3182 done
3183
3184 fi
3185 fi
3186 CC=$ac_cv_prog_CC
3187 if test -n "$CC"; then
3188   echo "$as_me:$LINENO: result: $CC" >&5
3189 echo "${ECHO_T}$CC" >&6
3190 else
3191   echo "$as_me:$LINENO: result: no" >&5
3192 echo "${ECHO_T}no" >&6
3193 fi
3194
3195     test -n "$CC" && break
3196   done
3197 fi
3198 if test -z "$CC"; then
3199   ac_ct_CC=$CC
3200   for ac_prog in cl
3201 do
3202   # Extract the first word of "$ac_prog", so it can be a program name with args.
3203 set dummy $ac_prog; ac_word=$2
3204 echo "$as_me:$LINENO: checking for $ac_word" >&5
3205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3206 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3207   echo $ECHO_N "(cached) $ECHO_C" >&6
3208 else
3209   if test -n "$ac_ct_CC"; then
3210   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3211 else
3212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3213 for as_dir in $PATH
3214 do
3215   IFS=$as_save_IFS
3216   test -z "$as_dir" && as_dir=.
3217   for ac_exec_ext in '' $ac_executable_extensions; do
3218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3219     ac_cv_prog_ac_ct_CC="$ac_prog"
3220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3221     break 2
3222   fi
3223 done
3224 done
3225
3226 fi
3227 fi
3228 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3229 if test -n "$ac_ct_CC"; then
3230   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3231 echo "${ECHO_T}$ac_ct_CC" >&6
3232 else
3233   echo "$as_me:$LINENO: result: no" >&5
3234 echo "${ECHO_T}no" >&6
3235 fi
3236
3237   test -n "$ac_ct_CC" && break
3238 done
3239
3240   CC=$ac_ct_CC
3241 fi
3242
3243 fi
3244
3245
3246 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3247 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3248 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3249 See \`config.log' for more details." >&5
3250 echo "$as_me: error: no acceptable C compiler found in \$PATH
3251 See \`config.log' for more details." >&2;}
3252    { (exit 1); exit 1; }; }; }
3253
3254 # Provide some information about the compiler.
3255 echo "$as_me:$LINENO:" \
3256      "checking for C compiler version" >&5
3257 ac_compiler=`set X $ac_compile; echo $2`
3258 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3259   (eval $ac_compiler --version </dev/null >&5) 2>&5
3260   ac_status=$?
3261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3262   (exit $ac_status); }
3263 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3264   (eval $ac_compiler -v </dev/null >&5) 2>&5
3265   ac_status=$?
3266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3267   (exit $ac_status); }
3268 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3269   (eval $ac_compiler -V </dev/null >&5) 2>&5
3270   ac_status=$?
3271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3272   (exit $ac_status); }
3273
3274 cat >conftest.$ac_ext <<_ACEOF
3275 /* confdefs.h.  */
3276 _ACEOF
3277 cat confdefs.h >>conftest.$ac_ext
3278 cat >>conftest.$ac_ext <<_ACEOF
3279 /* end confdefs.h.  */
3280
3281 int
3282 main ()
3283 {
3284
3285   ;
3286   return 0;
3287 }
3288 _ACEOF
3289 ac_clean_files_save=$ac_clean_files
3290 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3291 # Try to create an executable without -o first, disregard a.out.
3292 # It will help us diagnose broken compilers, and finding out an intuition
3293 # of exeext.
3294 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3295 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3296 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3297 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3298   (eval $ac_link_default) 2>&5
3299   ac_status=$?
3300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3301   (exit $ac_status); }; then
3302   # Find the output, starting from the most likely.  This scheme is
3303 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3304 # resort.
3305
3306 # Be careful to initialize this variable, since it used to be cached.
3307 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3308 ac_cv_exeext=
3309 # b.out is created by i960 compilers.
3310 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3311 do
3312   test -f "$ac_file" || continue
3313   case $ac_file in
3314     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3315         ;;
3316     conftest.$ac_ext )
3317         # This is the source file.
3318         ;;
3319     [ab].out )
3320         # We found the default executable, but exeext='' is most
3321         # certainly right.
3322         break;;
3323     *.* )
3324         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3325         # FIXME: I believe we export ac_cv_exeext for Libtool,
3326         # but it would be cool to find out if it's true.  Does anybody
3327         # maintain Libtool? --akim.
3328         export ac_cv_exeext
3329         break;;
3330     * )
3331         break;;
3332   esac
3333 done
3334 else
3335   echo "$as_me: failed program was:" >&5
3336 sed 's/^/| /' conftest.$ac_ext >&5
3337
3338 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3339 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3340 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3341 See \`config.log' for more details." >&5
3342 echo "$as_me: error: C compiler cannot create executables
3343 See \`config.log' for more details." >&2;}
3344    { (exit 77); exit 77; }; }; }
3345 fi
3346
3347 ac_exeext=$ac_cv_exeext
3348 echo "$as_me:$LINENO: result: $ac_file" >&5
3349 echo "${ECHO_T}$ac_file" >&6
3350
3351 # Check the compiler produces executables we can run.  If not, either
3352 # the compiler is broken, or we cross compile.
3353 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3354 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3355 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3356 # If not cross compiling, check that we can run a simple program.
3357 if test "$cross_compiling" != yes; then
3358   if { ac_try='./$ac_file'
3359   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3360   (eval $ac_try) 2>&5
3361   ac_status=$?
3362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3363   (exit $ac_status); }; }; then
3364     cross_compiling=no
3365   else
3366     if test "$cross_compiling" = maybe; then
3367         cross_compiling=yes
3368     else
3369         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3370 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3371 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3372 If you meant to cross compile, use \`--host'.
3373 See \`config.log' for more details." >&5
3374 echo "$as_me: error: cannot run C compiled programs.
3375 If you meant to cross compile, use \`--host'.
3376 See \`config.log' for more details." >&2;}
3377    { (exit 1); exit 1; }; }; }
3378     fi
3379   fi
3380 fi
3381 echo "$as_me:$LINENO: result: yes" >&5
3382 echo "${ECHO_T}yes" >&6
3383
3384 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3385 ac_clean_files=$ac_clean_files_save
3386 # Check the compiler produces executables we can run.  If not, either
3387 # the compiler is broken, or we cross compile.
3388 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3389 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3390 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3391 echo "${ECHO_T}$cross_compiling" >&6
3392
3393 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3394 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3395 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3396   (eval $ac_link) 2>&5
3397   ac_status=$?
3398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3399   (exit $ac_status); }; then
3400   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3401 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3402 # work properly (i.e., refer to `conftest.exe'), while it won't with
3403 # `rm'.
3404 for ac_file in conftest.exe conftest conftest.*; do
3405   test -f "$ac_file" || continue
3406   case $ac_file in
3407     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3408     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3409           export ac_cv_exeext
3410           break;;
3411     * ) break;;
3412   esac
3413 done
3414 else
3415   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3416 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3417 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3418 See \`config.log' for more details." >&5
3419 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3420 See \`config.log' for more details." >&2;}
3421    { (exit 1); exit 1; }; }; }
3422 fi
3423
3424 rm -f conftest$ac_cv_exeext
3425 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3426 echo "${ECHO_T}$ac_cv_exeext" >&6
3427
3428 rm -f conftest.$ac_ext
3429 EXEEXT=$ac_cv_exeext
3430 ac_exeext=$EXEEXT
3431 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3432 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3433 if test "${ac_cv_objext+set}" = set; then
3434   echo $ECHO_N "(cached) $ECHO_C" >&6
3435 else
3436   cat >conftest.$ac_ext <<_ACEOF
3437 /* confdefs.h.  */
3438 _ACEOF
3439 cat confdefs.h >>conftest.$ac_ext
3440 cat >>conftest.$ac_ext <<_ACEOF
3441 /* end confdefs.h.  */
3442
3443 int
3444 main ()
3445 {
3446
3447   ;
3448   return 0;
3449 }
3450 _ACEOF
3451 rm -f conftest.o conftest.obj
3452 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3453   (eval $ac_compile) 2>&5
3454   ac_status=$?
3455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3456   (exit $ac_status); }; then
3457   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3458   case $ac_file in
3459     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3460     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3461        break;;
3462   esac
3463 done
3464 else
3465   echo "$as_me: failed program was:" >&5
3466 sed 's/^/| /' conftest.$ac_ext >&5
3467
3468 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3469 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3470 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3471 See \`config.log' for more details." >&5
3472 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3473 See \`config.log' for more details." >&2;}
3474    { (exit 1); exit 1; }; }; }
3475 fi
3476
3477 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3478 fi
3479 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3480 echo "${ECHO_T}$ac_cv_objext" >&6
3481 OBJEXT=$ac_cv_objext
3482 ac_objext=$OBJEXT
3483 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3484 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3485 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3486   echo $ECHO_N "(cached) $ECHO_C" >&6
3487 else
3488   cat >conftest.$ac_ext <<_ACEOF
3489 /* confdefs.h.  */
3490 _ACEOF
3491 cat confdefs.h >>conftest.$ac_ext
3492 cat >>conftest.$ac_ext <<_ACEOF
3493 /* end confdefs.h.  */
3494
3495 int
3496 main ()
3497 {
3498 #ifndef __GNUC__
3499        choke me
3500 #endif
3501
3502   ;
3503   return 0;
3504 }
3505 _ACEOF
3506 rm -f conftest.$ac_objext
3507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3508   (eval $ac_compile) 2>conftest.er1
3509   ac_status=$?
3510   grep -v '^ *+' conftest.er1 >conftest.err
3511   rm -f conftest.er1
3512   cat conftest.err >&5
3513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3514   (exit $ac_status); } &&
3515          { ac_try='test -z "$ac_c_werror_flag"
3516                          || test ! -s conftest.err'
3517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3518   (eval $ac_try) 2>&5
3519   ac_status=$?
3520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3521   (exit $ac_status); }; } &&
3522          { ac_try='test -s conftest.$ac_objext'
3523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3524   (eval $ac_try) 2>&5
3525   ac_status=$?
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); }; }; then
3528   ac_compiler_gnu=yes
3529 else
3530   echo "$as_me: failed program was:" >&5
3531 sed 's/^/| /' conftest.$ac_ext >&5
3532
3533 ac_compiler_gnu=no
3534 fi
3535 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3536 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3537
3538 fi
3539 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3540 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3541 GCC=`test $ac_compiler_gnu = yes && echo yes`
3542 ac_test_CFLAGS=${CFLAGS+set}
3543 ac_save_CFLAGS=$CFLAGS
3544 CFLAGS="-g"
3545 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3546 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3547 if test "${ac_cv_prog_cc_g+set}" = set; then
3548   echo $ECHO_N "(cached) $ECHO_C" >&6
3549 else
3550   cat >conftest.$ac_ext <<_ACEOF
3551 /* confdefs.h.  */
3552 _ACEOF
3553 cat confdefs.h >>conftest.$ac_ext
3554 cat >>conftest.$ac_ext <<_ACEOF
3555 /* end confdefs.h.  */
3556
3557 int
3558 main ()
3559 {
3560
3561   ;
3562   return 0;
3563 }
3564 _ACEOF
3565 rm -f conftest.$ac_objext
3566 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3567   (eval $ac_compile) 2>conftest.er1
3568   ac_status=$?
3569   grep -v '^ *+' conftest.er1 >conftest.err
3570   rm -f conftest.er1
3571   cat conftest.err >&5
3572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3573   (exit $ac_status); } &&
3574          { ac_try='test -z "$ac_c_werror_flag"
3575                          || test ! -s conftest.err'
3576   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3577   (eval $ac_try) 2>&5
3578   ac_status=$?
3579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3580   (exit $ac_status); }; } &&
3581          { ac_try='test -s conftest.$ac_objext'
3582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3583   (eval $ac_try) 2>&5
3584   ac_status=$?
3585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3586   (exit $ac_status); }; }; then
3587   ac_cv_prog_cc_g=yes
3588 else
3589   echo "$as_me: failed program was:" >&5
3590 sed 's/^/| /' conftest.$ac_ext >&5
3591
3592 ac_cv_prog_cc_g=no
3593 fi
3594 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3595 fi
3596 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3597 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3598 if test "$ac_test_CFLAGS" = set; then
3599   CFLAGS=$ac_save_CFLAGS
3600 elif test $ac_cv_prog_cc_g = yes; then
3601   if test "$GCC" = yes; then
3602     CFLAGS="-g -O2"
3603   else
3604     CFLAGS="-g"
3605   fi
3606 else
3607   if test "$GCC" = yes; then
3608     CFLAGS="-O2"
3609   else
3610     CFLAGS=
3611   fi
3612 fi
3613 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3614 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3615 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3616   echo $ECHO_N "(cached) $ECHO_C" >&6
3617 else
3618   ac_cv_prog_cc_stdc=no
3619 ac_save_CC=$CC
3620 cat >conftest.$ac_ext <<_ACEOF
3621 /* confdefs.h.  */
3622 _ACEOF
3623 cat confdefs.h >>conftest.$ac_ext
3624 cat >>conftest.$ac_ext <<_ACEOF
3625 /* end confdefs.h.  */
3626 #include <stdarg.h>
3627 #include <stdio.h>
3628 #include <sys/types.h>
3629 #include <sys/stat.h>
3630 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3631 struct buf { int x; };
3632 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3633 static char *e (p, i)
3634      char **p;
3635      int i;
3636 {
3637   return p[i];
3638 }
3639 static char *f (char * (*g) (char **, int), char **p, ...)
3640 {
3641   char *s;
3642   va_list v;
3643   va_start (v,p);
3644   s = g (p, va_arg (v,int));
3645   va_end (v);
3646   return s;
3647 }
3648
3649 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3650    function prototypes and stuff, but not '\xHH' hex character constants.
3651    These don't provoke an error unfortunately, instead are silently treated
3652    as 'x'.  The following induces an error, until -std1 is added to get
3653    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3654    array size at least.  It's necessary to write '\x00'==0 to get something
3655    that's true only with -std1.  */
3656 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3657
3658 int test (int i, double x);
3659 struct s1 {int (*f) (int a);};
3660 struct s2 {int (*f) (double a);};
3661 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3662 int argc;
3663 char **argv;
3664 int
3665 main ()
3666 {
3667 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3668   ;
3669   return 0;
3670 }
3671 _ACEOF
3672 # Don't try gcc -ansi; that turns off useful extensions and
3673 # breaks some systems' header files.
3674 # AIX                   -qlanglvl=ansi
3675 # Ultrix and OSF/1      -std1
3676 # HP-UX 10.20 and later -Ae
3677 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3678 # SVR4                  -Xc -D__EXTENSIONS__
3679 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3680 do
3681   CC="$ac_save_CC $ac_arg"
3682   rm -f conftest.$ac_objext
3683 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3684   (eval $ac_compile) 2>conftest.er1
3685   ac_status=$?
3686   grep -v '^ *+' conftest.er1 >conftest.err
3687   rm -f conftest.er1
3688   cat conftest.err >&5
3689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3690   (exit $ac_status); } &&
3691          { ac_try='test -z "$ac_c_werror_flag"
3692                          || test ! -s conftest.err'
3693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3694   (eval $ac_try) 2>&5
3695   ac_status=$?
3696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3697   (exit $ac_status); }; } &&
3698          { ac_try='test -s conftest.$ac_objext'
3699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3700   (eval $ac_try) 2>&5
3701   ac_status=$?
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); }; }; then
3704   ac_cv_prog_cc_stdc=$ac_arg
3705 break
3706 else
3707   echo "$as_me: failed program was:" >&5
3708 sed 's/^/| /' conftest.$ac_ext >&5
3709
3710 fi
3711 rm -f conftest.err conftest.$ac_objext
3712 done
3713 rm -f conftest.$ac_ext conftest.$ac_objext
3714 CC=$ac_save_CC
3715
3716 fi
3717
3718 case "x$ac_cv_prog_cc_stdc" in
3719   x|xno)
3720     echo "$as_me:$LINENO: result: none needed" >&5
3721 echo "${ECHO_T}none needed" >&6 ;;
3722   *)
3723     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3724 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3725     CC="$CC $ac_cv_prog_cc_stdc" ;;
3726 esac
3727
3728 # Some people use a C++ compiler to compile C.  Since we use `exit',
3729 # in C++ we need to declare it.  In case someone uses the same compiler
3730 # for both compiling C and C++ we need to have the C++ compiler decide
3731 # the declaration of exit, since it's the most demanding environment.
3732 cat >conftest.$ac_ext <<_ACEOF
3733 #ifndef __cplusplus
3734   choke me
3735 #endif
3736 _ACEOF
3737 rm -f conftest.$ac_objext
3738 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3739   (eval $ac_compile) 2>conftest.er1
3740   ac_status=$?
3741   grep -v '^ *+' conftest.er1 >conftest.err
3742   rm -f conftest.er1
3743   cat conftest.err >&5
3744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745   (exit $ac_status); } &&
3746          { ac_try='test -z "$ac_c_werror_flag"
3747                          || test ! -s conftest.err'
3748   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3749   (eval $ac_try) 2>&5
3750   ac_status=$?
3751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3752   (exit $ac_status); }; } &&
3753          { ac_try='test -s conftest.$ac_objext'
3754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3755   (eval $ac_try) 2>&5
3756   ac_status=$?
3757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758   (exit $ac_status); }; }; then
3759   for ac_declaration in \
3760    '' \
3761    'extern "C" void std::exit (int) throw (); using std::exit;' \
3762    'extern "C" void std::exit (int); using std::exit;' \
3763    'extern "C" void exit (int) throw ();' \
3764    'extern "C" void exit (int);' \
3765    'void exit (int);'
3766 do
3767   cat >conftest.$ac_ext <<_ACEOF
3768 /* confdefs.h.  */
3769 _ACEOF
3770 cat confdefs.h >>conftest.$ac_ext
3771 cat >>conftest.$ac_ext <<_ACEOF
3772 /* end confdefs.h.  */
3773 $ac_declaration
3774 #include <stdlib.h>
3775 int
3776 main ()
3777 {
3778 exit (42);
3779   ;
3780   return 0;
3781 }
3782 _ACEOF
3783 rm -f conftest.$ac_objext
3784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785   (eval $ac_compile) 2>conftest.er1
3786   ac_status=$?
3787   grep -v '^ *+' conftest.er1 >conftest.err
3788   rm -f conftest.er1
3789   cat conftest.err >&5
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); } &&
3792          { ac_try='test -z "$ac_c_werror_flag"
3793                          || test ! -s conftest.err'
3794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3795   (eval $ac_try) 2>&5
3796   ac_status=$?
3797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3798   (exit $ac_status); }; } &&
3799          { ac_try='test -s conftest.$ac_objext'
3800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3801   (eval $ac_try) 2>&5
3802   ac_status=$?
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); }; }; then
3805   :
3806 else
3807   echo "$as_me: failed program was:" >&5
3808 sed 's/^/| /' conftest.$ac_ext >&5
3809
3810 continue
3811 fi
3812 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3813   cat >conftest.$ac_ext <<_ACEOF
3814 /* confdefs.h.  */
3815 _ACEOF
3816 cat confdefs.h >>conftest.$ac_ext
3817 cat >>conftest.$ac_ext <<_ACEOF
3818 /* end confdefs.h.  */
3819 $ac_declaration
3820 int
3821 main ()
3822 {
3823 exit (42);
3824   ;
3825   return 0;
3826 }
3827 _ACEOF
3828 rm -f conftest.$ac_objext
3829 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3830   (eval $ac_compile) 2>conftest.er1
3831   ac_status=$?
3832   grep -v '^ *+' conftest.er1 >conftest.err
3833   rm -f conftest.er1
3834   cat conftest.err >&5
3835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3836   (exit $ac_status); } &&
3837          { ac_try='test -z "$ac_c_werror_flag"
3838                          || test ! -s conftest.err'
3839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3840   (eval $ac_try) 2>&5
3841   ac_status=$?
3842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3843   (exit $ac_status); }; } &&
3844          { ac_try='test -s conftest.$ac_objext'
3845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3846   (eval $ac_try) 2>&5
3847   ac_status=$?
3848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3849   (exit $ac_status); }; }; then
3850   break
3851 else
3852   echo "$as_me: failed program was:" >&5
3853 sed 's/^/| /' conftest.$ac_ext >&5
3854
3855 fi
3856 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3857 done
3858 rm -f conftest*
3859 if test -n "$ac_declaration"; then
3860   echo '#ifdef __cplusplus' >>confdefs.h
3861   echo $ac_declaration      >>confdefs.h
3862   echo '#endif'             >>confdefs.h
3863 fi
3864
3865 else
3866   echo "$as_me: failed program was:" >&5
3867 sed 's/^/| /' conftest.$ac_ext >&5
3868
3869 fi
3870 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3871 ac_ext=c
3872 ac_cpp='$CPP $CPPFLAGS'
3873 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3874 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3875 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3876
3877 ac_ext=cc
3878 ac_cpp='$CXXCPP $CPPFLAGS'
3879 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3880 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3881 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3882 if test -n "$ac_tool_prefix"; then
3883   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3884   do
3885     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3886 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3887 echo "$as_me:$LINENO: checking for $ac_word" >&5
3888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3889 if test "${ac_cv_prog_CXX+set}" = set; then
3890   echo $ECHO_N "(cached) $ECHO_C" >&6
3891 else
3892   if test -n "$CXX"; then
3893   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3894 else
3895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3896 for as_dir in $PATH
3897 do
3898   IFS=$as_save_IFS
3899   test -z "$as_dir" && as_dir=.
3900   for ac_exec_ext in '' $ac_executable_extensions; do
3901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3902     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3904     break 2
3905   fi
3906 done
3907 done
3908
3909 fi
3910 fi
3911 CXX=$ac_cv_prog_CXX
3912 if test -n "$CXX"; then
3913   echo "$as_me:$LINENO: result: $CXX" >&5
3914 echo "${ECHO_T}$CXX" >&6
3915 else
3916   echo "$as_me:$LINENO: result: no" >&5
3917 echo "${ECHO_T}no" >&6
3918 fi
3919
3920     test -n "$CXX" && break
3921   done
3922 fi
3923 if test -z "$CXX"; then
3924   ac_ct_CXX=$CXX
3925   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3926 do
3927   # Extract the first word of "$ac_prog", so it can be a program name with args.
3928 set dummy $ac_prog; ac_word=$2
3929 echo "$as_me:$LINENO: checking for $ac_word" >&5
3930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3931 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3932   echo $ECHO_N "(cached) $ECHO_C" >&6
3933 else
3934   if test -n "$ac_ct_CXX"; then
3935   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3936 else
3937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3938 for as_dir in $PATH
3939 do
3940   IFS=$as_save_IFS
3941   test -z "$as_dir" && as_dir=.
3942   for ac_exec_ext in '' $ac_executable_extensions; do
3943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3944     ac_cv_prog_ac_ct_CXX="$ac_prog"
3945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3946     break 2
3947   fi
3948 done
3949 done
3950
3951 fi
3952 fi
3953 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3954 if test -n "$ac_ct_CXX"; then
3955   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3956 echo "${ECHO_T}$ac_ct_CXX" >&6
3957 else
3958   echo "$as_me:$LINENO: result: no" >&5
3959 echo "${ECHO_T}no" >&6
3960 fi
3961
3962   test -n "$ac_ct_CXX" && break
3963 done
3964 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3965
3966   CXX=$ac_ct_CXX
3967 fi
3968
3969
3970 # Provide some information about the compiler.
3971 echo "$as_me:$LINENO:" \
3972      "checking for C++ compiler version" >&5
3973 ac_compiler=`set X $ac_compile; echo $2`
3974 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3975   (eval $ac_compiler --version </dev/null >&5) 2>&5
3976   ac_status=$?
3977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978   (exit $ac_status); }
3979 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3980   (eval $ac_compiler -v </dev/null >&5) 2>&5
3981   ac_status=$?
3982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3983   (exit $ac_status); }
3984 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3985   (eval $ac_compiler -V </dev/null >&5) 2>&5
3986   ac_status=$?
3987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3988   (exit $ac_status); }
3989
3990 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3991 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3992 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3993   echo $ECHO_N "(cached) $ECHO_C" >&6
3994 else
3995   cat >conftest.$ac_ext <<_ACEOF
3996 /* confdefs.h.  */
3997 _ACEOF
3998 cat confdefs.h >>conftest.$ac_ext
3999 cat >>conftest.$ac_ext <<_ACEOF
4000 /* end confdefs.h.  */
4001
4002 int
4003 main ()
4004 {
4005 #ifndef __GNUC__
4006        choke me
4007 #endif
4008
4009   ;
4010   return 0;
4011 }
4012 _ACEOF
4013 rm -f conftest.$ac_objext
4014 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4015   (eval $ac_compile) 2>conftest.er1
4016   ac_status=$?
4017   grep -v '^ *+' conftest.er1 >conftest.err
4018   rm -f conftest.er1
4019   cat conftest.err >&5
4020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4021   (exit $ac_status); } &&
4022          { ac_try='test -z "$ac_cxx_werror_flag"
4023                          || test ! -s conftest.err'
4024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4025   (eval $ac_try) 2>&5
4026   ac_status=$?
4027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4028   (exit $ac_status); }; } &&
4029          { ac_try='test -s conftest.$ac_objext'
4030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4031   (eval $ac_try) 2>&5
4032   ac_status=$?
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); }; }; then
4035   ac_compiler_gnu=yes
4036 else
4037   echo "$as_me: failed program was:" >&5
4038 sed 's/^/| /' conftest.$ac_ext >&5
4039
4040 ac_compiler_gnu=no
4041 fi
4042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4043 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4044
4045 fi
4046 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4047 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4048 GXX=`test $ac_compiler_gnu = yes && echo yes`
4049 ac_test_CXXFLAGS=${CXXFLAGS+set}
4050 ac_save_CXXFLAGS=$CXXFLAGS
4051 CXXFLAGS="-g"
4052 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4053 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4054 if test "${ac_cv_prog_cxx_g+set}" = set; then
4055   echo $ECHO_N "(cached) $ECHO_C" >&6
4056 else
4057   cat >conftest.$ac_ext <<_ACEOF
4058 /* confdefs.h.  */
4059 _ACEOF
4060 cat confdefs.h >>conftest.$ac_ext
4061 cat >>conftest.$ac_ext <<_ACEOF
4062 /* end confdefs.h.  */
4063
4064 int
4065 main ()
4066 {
4067
4068   ;
4069   return 0;
4070 }
4071 _ACEOF
4072 rm -f conftest.$ac_objext
4073 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4074   (eval $ac_compile) 2>conftest.er1
4075   ac_status=$?
4076   grep -v '^ *+' conftest.er1 >conftest.err
4077   rm -f conftest.er1
4078   cat conftest.err >&5
4079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4080   (exit $ac_status); } &&
4081          { ac_try='test -z "$ac_cxx_werror_flag"
4082                          || test ! -s conftest.err'
4083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4084   (eval $ac_try) 2>&5
4085   ac_status=$?
4086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4087   (exit $ac_status); }; } &&
4088          { ac_try='test -s conftest.$ac_objext'
4089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4090   (eval $ac_try) 2>&5
4091   ac_status=$?
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); }; }; then
4094   ac_cv_prog_cxx_g=yes
4095 else
4096   echo "$as_me: failed program was:" >&5
4097 sed 's/^/| /' conftest.$ac_ext >&5
4098
4099 ac_cv_prog_cxx_g=no
4100 fi
4101 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4102 fi
4103 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4104 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4105 if test "$ac_test_CXXFLAGS" = set; then
4106   CXXFLAGS=$ac_save_CXXFLAGS
4107 elif test $ac_cv_prog_cxx_g = yes; then
4108   if test "$GXX" = yes; then
4109     CXXFLAGS="-g -O2"
4110   else
4111     CXXFLAGS="-g"
4112   fi
4113 else
4114   if test "$GXX" = yes; then
4115     CXXFLAGS="-O2"
4116   else
4117     CXXFLAGS=
4118   fi
4119 fi
4120 for ac_declaration in \
4121    '' \
4122    'extern "C" void std::exit (int) throw (); using std::exit;' \
4123    'extern "C" void std::exit (int); using std::exit;' \
4124    'extern "C" void exit (int) throw ();' \
4125    'extern "C" void exit (int);' \
4126    'void exit (int);'
4127 do
4128   cat >conftest.$ac_ext <<_ACEOF
4129 /* confdefs.h.  */
4130 _ACEOF
4131 cat confdefs.h >>conftest.$ac_ext
4132 cat >>conftest.$ac_ext <<_ACEOF
4133 /* end confdefs.h.  */
4134 $ac_declaration
4135 #include <stdlib.h>
4136 int
4137 main ()
4138 {
4139 exit (42);
4140   ;
4141   return 0;
4142 }
4143 _ACEOF
4144 rm -f conftest.$ac_objext
4145 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4146   (eval $ac_compile) 2>conftest.er1
4147   ac_status=$?
4148   grep -v '^ *+' conftest.er1 >conftest.err
4149   rm -f conftest.er1
4150   cat conftest.err >&5
4151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4152   (exit $ac_status); } &&
4153          { ac_try='test -z "$ac_cxx_werror_flag"
4154                          || test ! -s conftest.err'
4155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4156   (eval $ac_try) 2>&5
4157   ac_status=$?
4158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4159   (exit $ac_status); }; } &&
4160          { ac_try='test -s conftest.$ac_objext'
4161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4162   (eval $ac_try) 2>&5
4163   ac_status=$?
4164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4165   (exit $ac_status); }; }; then
4166   :
4167 else
4168   echo "$as_me: failed program was:" >&5
4169 sed 's/^/| /' conftest.$ac_ext >&5
4170
4171 continue
4172 fi
4173 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4174   cat >conftest.$ac_ext <<_ACEOF
4175 /* confdefs.h.  */
4176 _ACEOF
4177 cat confdefs.h >>conftest.$ac_ext
4178 cat >>conftest.$ac_ext <<_ACEOF
4179 /* end confdefs.h.  */
4180 $ac_declaration
4181 int
4182 main ()
4183 {
4184 exit (42);
4185   ;
4186   return 0;
4187 }
4188 _ACEOF
4189 rm -f conftest.$ac_objext
4190 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4191   (eval $ac_compile) 2>conftest.er1
4192   ac_status=$?
4193   grep -v '^ *+' conftest.er1 >conftest.err
4194   rm -f conftest.er1
4195   cat conftest.err >&5
4196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4197   (exit $ac_status); } &&
4198          { ac_try='test -z "$ac_cxx_werror_flag"
4199                          || test ! -s conftest.err'
4200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4201   (eval $ac_try) 2>&5
4202   ac_status=$?
4203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4204   (exit $ac_status); }; } &&
4205          { ac_try='test -s conftest.$ac_objext'
4206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4207   (eval $ac_try) 2>&5
4208   ac_status=$?
4209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4210   (exit $ac_status); }; }; then
4211   break
4212 else
4213   echo "$as_me: failed program was:" >&5
4214 sed 's/^/| /' conftest.$ac_ext >&5
4215
4216 fi
4217 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4218 done
4219 rm -f conftest*
4220 if test -n "$ac_declaration"; then
4221   echo '#ifdef __cplusplus' >>confdefs.h
4222   echo $ac_declaration      >>confdefs.h
4223   echo '#endif'             >>confdefs.h
4224 fi
4225
4226 ac_ext=c
4227 ac_cpp='$CPP $CPPFLAGS'
4228 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4229 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4230 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4231
4232
4233 # We must set the default linker to the linker used by gcc for the correct
4234 # operation of libtool.  If LD is not defined and we are using gcc, try to
4235 # set the LD default to the ld used by gcc.
4236 if test -z "$LD"; then
4237   if test "$GCC" = yes; then
4238     case $build in
4239     *-*-mingw*)
4240       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4241     *)
4242       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4243     esac
4244     case $gcc_prog_ld in
4245     # Accept absolute paths.
4246     [\\/]* | [A-Za-z]:[\\/]*)
4247       LD="$gcc_prog_ld" ;;
4248     esac
4249   fi
4250 fi
4251
4252
4253
4254
4255 if test -n "$ac_tool_prefix"; then
4256   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4257 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4258 echo "$as_me:$LINENO: checking for $ac_word" >&5
4259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4260 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4261   echo $ECHO_N "(cached) $ECHO_C" >&6
4262 else
4263   if test -n "$GNATBIND"; then
4264   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4265 else
4266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4267 for as_dir in $PATH
4268 do
4269   IFS=$as_save_IFS
4270   test -z "$as_dir" && as_dir=.
4271   for ac_exec_ext in '' $ac_executable_extensions; do
4272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4273     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4275     break 2
4276   fi
4277 done
4278 done
4279
4280 fi
4281 fi
4282 GNATBIND=$ac_cv_prog_GNATBIND
4283 if test -n "$GNATBIND"; then
4284   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4285 echo "${ECHO_T}$GNATBIND" >&6
4286 else
4287   echo "$as_me:$LINENO: result: no" >&5
4288 echo "${ECHO_T}no" >&6
4289 fi
4290
4291 fi
4292 if test -z "$ac_cv_prog_GNATBIND"; then
4293   ac_ct_GNATBIND=$GNATBIND
4294   # Extract the first word of "gnatbind", so it can be a program name with args.
4295 set dummy gnatbind; ac_word=$2
4296 echo "$as_me:$LINENO: checking for $ac_word" >&5
4297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4298 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4299   echo $ECHO_N "(cached) $ECHO_C" >&6
4300 else
4301   if test -n "$ac_ct_GNATBIND"; then
4302   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4303 else
4304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4305 for as_dir in $PATH
4306 do
4307   IFS=$as_save_IFS
4308   test -z "$as_dir" && as_dir=.
4309   for ac_exec_ext in '' $ac_executable_extensions; do
4310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4311     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4313     break 2
4314   fi
4315 done
4316 done
4317
4318   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4319 fi
4320 fi
4321 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4322 if test -n "$ac_ct_GNATBIND"; then
4323   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4324 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4325 else
4326   echo "$as_me:$LINENO: result: no" >&5
4327 echo "${ECHO_T}no" >&6
4328 fi
4329
4330   GNATBIND=$ac_ct_GNATBIND
4331 else
4332   GNATBIND="$ac_cv_prog_GNATBIND"
4333 fi
4334
4335 if test -n "$ac_tool_prefix"; then
4336   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4337 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4338 echo "$as_me:$LINENO: checking for $ac_word" >&5
4339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4340 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4341   echo $ECHO_N "(cached) $ECHO_C" >&6
4342 else
4343   if test -n "$GNATMAKE"; then
4344   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4345 else
4346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4347 for as_dir in $PATH
4348 do
4349   IFS=$as_save_IFS
4350   test -z "$as_dir" && as_dir=.
4351   for ac_exec_ext in '' $ac_executable_extensions; do
4352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4353     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4355     break 2
4356   fi
4357 done
4358 done
4359
4360 fi
4361 fi
4362 GNATMAKE=$ac_cv_prog_GNATMAKE
4363 if test -n "$GNATMAKE"; then
4364   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4365 echo "${ECHO_T}$GNATMAKE" >&6
4366 else
4367   echo "$as_me:$LINENO: result: no" >&5
4368 echo "${ECHO_T}no" >&6
4369 fi
4370
4371 fi
4372 if test -z "$ac_cv_prog_GNATMAKE"; then
4373   ac_ct_GNATMAKE=$GNATMAKE
4374   # Extract the first word of "gnatmake", so it can be a program name with args.
4375 set dummy gnatmake; ac_word=$2
4376 echo "$as_me:$LINENO: checking for $ac_word" >&5
4377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4378 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4379   echo $ECHO_N "(cached) $ECHO_C" >&6
4380 else
4381   if test -n "$ac_ct_GNATMAKE"; then
4382   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4383 else
4384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4385 for as_dir in $PATH
4386 do
4387   IFS=$as_save_IFS
4388   test -z "$as_dir" && as_dir=.
4389   for ac_exec_ext in '' $ac_executable_extensions; do
4390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4391     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4393     break 2
4394   fi
4395 done
4396 done
4397
4398   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4399 fi
4400 fi
4401 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4402 if test -n "$ac_ct_GNATMAKE"; then
4403   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4404 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4405 else
4406   echo "$as_me:$LINENO: result: no" >&5
4407 echo "${ECHO_T}no" >&6
4408 fi
4409
4410   GNATMAKE=$ac_ct_GNATMAKE
4411 else
4412   GNATMAKE="$ac_cv_prog_GNATMAKE"
4413 fi
4414
4415 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4416 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4417 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4418   echo $ECHO_N "(cached) $ECHO_C" >&6
4419 else
4420   cat >conftest.adb <<EOF
4421 procedure conftest is begin null; end conftest;
4422 EOF
4423 acx_cv_cc_gcc_supports_ada=no
4424 # There is a bug in old released versions of GCC which causes the
4425 # driver to exit successfully when the appropriate language module
4426 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4427 # Therefore we must check for the error message as well as an
4428 # unsuccessful exit.
4429 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4430 # given a .adb file, but produce no object file.  So we must check
4431 # if an object file was really produced to guard against this.
4432 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4433 if test x"$errors" = x && test -f conftest.$ac_objext; then
4434   acx_cv_cc_gcc_supports_ada=yes
4435 fi
4436 rm -f conftest.*
4437 fi
4438 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4439 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4440
4441 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4442   have_gnat=yes
4443 else
4444   have_gnat=no
4445 fi
4446
4447 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4448 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4449 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4450   echo $ECHO_N "(cached) $ECHO_C" >&6
4451 else
4452    echo abfoo >t1
4453   echo cdfoo >t2
4454   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4455   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4456     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4457       :
4458     else
4459       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4460     fi
4461   fi
4462   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4463     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4464       :
4465     else
4466       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4467     fi
4468   fi
4469   rm t1 t2
4470
4471 fi
4472 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4473 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4474 do_compare="$gcc_cv_prog_cmp_skip"
4475
4476
4477
4478 # Check for GMP and MPFR
4479 gmplibs="-lmpfr -lgmp"
4480 gmpinc=
4481 have_gmp=no
4482
4483 # Specify a location for mpfr
4484 # check for this first so it ends up on the link line before gmp.
4485
4486 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4487 if test "${with_mpfr_dir+set}" = set; then
4488   withval="$with_mpfr_dir"
4489   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4490 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4491 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4492 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4493    { (exit 1); exit 1; }; }
4494 fi;
4495
4496
4497 # Check whether --with-mpfr or --without-mpfr was given.
4498 if test "${with_mpfr+set}" = set; then
4499   withval="$with_mpfr"
4500
4501 fi;
4502
4503 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4504 if test "${with_mpfr_include+set}" = set; then
4505   withval="$with_mpfr_include"
4506
4507 fi;
4508
4509 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4510 if test "${with_mpfr_lib+set}" = set; then
4511   withval="$with_mpfr_lib"
4512
4513 fi;
4514
4515 if test "x$with_mpfr" != x; then
4516   gmplibs="-L$with_mpfr/lib $gmplibs"
4517   gmpinc="-I$with_mpfr/include"
4518 fi
4519 if test "x$with_mpfr_include" != x; then
4520   gmpinc="-I$with_mpfr_include"
4521 fi
4522 if test "x$with_mpfr_lib" != x; then
4523   gmplibs="-L$with_mpfr_lib $gmplibs"
4524 fi
4525 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4526   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4527   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4528   # Do not test the mpfr version.  Assume that it is sufficient, since
4529   # it is in the source tree, and the library has not been built yet
4530   # but it would be included on the link line in the version check below
4531   # hence making the test fail.
4532   have_gmp=yes
4533 fi
4534
4535 # Specify a location for gmp
4536
4537 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4538 if test "${with_gmp_dir+set}" = set; then
4539   withval="$with_gmp_dir"
4540   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4541 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4542 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4543 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4544    { (exit 1); exit 1; }; }
4545 fi;
4546
4547
4548 # Check whether --with-gmp or --without-gmp was given.
4549 if test "${with_gmp+set}" = set; then
4550   withval="$with_gmp"
4551
4552 fi;
4553
4554 # Check whether --with-gmp_include or --without-gmp_include was given.
4555 if test "${with_gmp_include+set}" = set; then
4556   withval="$with_gmp_include"
4557
4558 fi;
4559
4560 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4561 if test "${with_gmp_lib+set}" = set; then
4562   withval="$with_gmp_lib"
4563
4564 fi;
4565
4566
4567 if test "x$with_gmp" != x; then
4568   gmplibs="-L$with_gmp/lib $gmplibs"
4569   gmpinc="-I$with_gmp/include $gmpinc"
4570 fi
4571 if test "x$with_gmp_include" != x; then
4572   gmpinc="-I$with_gmp_include $gmpinc"
4573 fi
4574 if test "x$with_gmp_lib" != x; then
4575   gmplibs="-L$with_gmp_lib $gmplibs"
4576 fi
4577 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4578   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4579   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4580   # Do not test the gmp version.  Assume that it is sufficient, since
4581   # it is in the source tree, and the library has not been built yet
4582   # but it would be included on the link line in the version check below
4583   # hence making the test fail.
4584   have_gmp=yes
4585 fi
4586
4587 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4588   have_gmp=yes
4589   saved_CFLAGS="$CFLAGS"
4590   CFLAGS="$CFLAGS $gmpinc"
4591   # Check GMP actually works
4592   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4593 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4594
4595 cat >conftest.$ac_ext <<_ACEOF
4596 /* confdefs.h.  */
4597 _ACEOF
4598 cat confdefs.h >>conftest.$ac_ext
4599 cat >>conftest.$ac_ext <<_ACEOF
4600 /* end confdefs.h.  */
4601 #include "gmp.h"
4602 int
4603 main ()
4604 {
4605
4606   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4607   choke me
4608   #endif
4609
4610   ;
4611   return 0;
4612 }
4613 _ACEOF
4614 rm -f conftest.$ac_objext
4615 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4616   (eval $ac_compile) 2>conftest.er1
4617   ac_status=$?
4618   grep -v '^ *+' conftest.er1 >conftest.err
4619   rm -f conftest.er1
4620   cat conftest.err >&5
4621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4622   (exit $ac_status); } &&
4623          { ac_try='test -z "$ac_c_werror_flag"
4624                          || test ! -s conftest.err'
4625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4626   (eval $ac_try) 2>&5
4627   ac_status=$?
4628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4629   (exit $ac_status); }; } &&
4630          { ac_try='test -s conftest.$ac_objext'
4631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4632   (eval $ac_try) 2>&5
4633   ac_status=$?
4634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4635   (exit $ac_status); }; }; then
4636   echo "$as_me:$LINENO: result: yes" >&5
4637 echo "${ECHO_T}yes" >&6
4638 else
4639   echo "$as_me: failed program was:" >&5
4640 sed 's/^/| /' conftest.$ac_ext >&5
4641
4642 echo "$as_me:$LINENO: result: no" >&5
4643 echo "${ECHO_T}no" >&6; have_gmp=no
4644 fi
4645 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4646
4647   if test x"$have_gmp" = xyes; then
4648     saved_LIBS="$LIBS"
4649     LIBS="$LIBS $gmplibs"
4650         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4651 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4652     cat >conftest.$ac_ext <<_ACEOF
4653 /* confdefs.h.  */
4654 _ACEOF
4655 cat confdefs.h >>conftest.$ac_ext
4656 cat >>conftest.$ac_ext <<_ACEOF
4657 /* end confdefs.h.  */
4658 #include <gmp.h>
4659     #include <mpfr.h>
4660 int
4661 main ()
4662 {
4663
4664     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4665     choke me
4666     #endif
4667     mpfr_t n;
4668     mpfr_t x;
4669     int t;
4670     mpfr_init (n);
4671     mpfr_init (x);
4672     mpfr_atan2 (n, n, x, GMP_RNDN);
4673     mpfr_erfc (n, x, GMP_RNDN);
4674     mpfr_subnormalize (x, t, GMP_RNDN);
4675
4676   ;
4677   return 0;
4678 }
4679 _ACEOF
4680 rm -f conftest.$ac_objext conftest$ac_exeext
4681 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4682   (eval $ac_link) 2>conftest.er1
4683   ac_status=$?
4684   grep -v '^ *+' conftest.er1 >conftest.err
4685   rm -f conftest.er1
4686   cat conftest.err >&5
4687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4688   (exit $ac_status); } &&
4689          { ac_try='test -z "$ac_c_werror_flag"
4690                          || test ! -s conftest.err'
4691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4692   (eval $ac_try) 2>&5
4693   ac_status=$?
4694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4695   (exit $ac_status); }; } &&
4696          { ac_try='test -s conftest$ac_exeext'
4697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4698   (eval $ac_try) 2>&5
4699   ac_status=$?
4700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4701   (exit $ac_status); }; }; then
4702   cat >conftest.$ac_ext <<_ACEOF
4703 /* confdefs.h.  */
4704 _ACEOF
4705 cat confdefs.h >>conftest.$ac_ext
4706 cat >>conftest.$ac_ext <<_ACEOF
4707 /* end confdefs.h.  */
4708 #include <gmp.h>
4709     #include <mpfr.h>
4710 int
4711 main ()
4712 {
4713
4714     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4715     choke me
4716     #endif
4717     mpfr_t n; mpfr_init(n);
4718
4719   ;
4720   return 0;
4721 }
4722 _ACEOF
4723 rm -f conftest.$ac_objext conftest$ac_exeext
4724 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4725   (eval $ac_link) 2>conftest.er1
4726   ac_status=$?
4727   grep -v '^ *+' conftest.er1 >conftest.err
4728   rm -f conftest.er1
4729   cat conftest.err >&5
4730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4731   (exit $ac_status); } &&
4732          { ac_try='test -z "$ac_c_werror_flag"
4733                          || test ! -s conftest.err'
4734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4735   (eval $ac_try) 2>&5
4736   ac_status=$?
4737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4738   (exit $ac_status); }; } &&
4739          { ac_try='test -s conftest$ac_exeext'
4740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4741   (eval $ac_try) 2>&5
4742   ac_status=$?
4743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4744   (exit $ac_status); }; }; then
4745   echo "$as_me:$LINENO: result: yes" >&5
4746 echo "${ECHO_T}yes" >&6
4747 else
4748   echo "$as_me: failed program was:" >&5
4749 sed 's/^/| /' conftest.$ac_ext >&5
4750
4751 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4752 echo "${ECHO_T}buggy but acceptable" >&6
4753 fi
4754 rm -f conftest.err conftest.$ac_objext \
4755       conftest$ac_exeext conftest.$ac_ext
4756 else
4757   echo "$as_me: failed program was:" >&5
4758 sed 's/^/| /' conftest.$ac_ext >&5
4759
4760 echo "$as_me:$LINENO: result: no" >&5
4761 echo "${ECHO_T}no" >&6; have_gmp=no
4762 fi
4763 rm -f conftest.err conftest.$ac_objext \
4764       conftest$ac_exeext conftest.$ac_ext
4765       LIBS="$saved_LIBS"
4766   fi
4767   CFLAGS="$saved_CFLAGS"
4768
4769   if test x$have_gmp != xyes; then
4770     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4771 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4772 Copies of these libraries' source code can be found at their respective
4773 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4774 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4775 If you obtained GMP and/or MPFR from a vendor distribution package, make
4776 sure that you have installed both the libraries and the header files.
4777 They may be located in separate packages." >&5
4778 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4779 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4780 Copies of these libraries' source code can be found at their respective
4781 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4782 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4783 If you obtained GMP and/or MPFR from a vendor distribution package, make
4784 sure that you have installed both the libraries and the header files.
4785 They may be located in separate packages." >&2;}
4786    { (exit 1); exit 1; }; }
4787   fi
4788 fi
4789
4790 # Flags needed for both GMP and/or MPFR
4791
4792
4793
4794 # By default, C is the only stage 1 language.
4795 stage1_languages=,c,
4796
4797 # Figure out what language subdirectories are present.
4798 # Look if the user specified --enable-languages="..."; if not, use
4799 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4800 # go away some day.
4801 # NB:  embedded tabs in this IF block -- do not untabify
4802 if test -d ${srcdir}/gcc; then
4803   if test x"${enable_languages+set}" != xset; then
4804     if test x"${LANGUAGES+set}" = xset; then
4805       enable_languages="${LANGUAGES}"
4806         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4807     else
4808       enable_languages=all
4809     fi
4810   else
4811     if test x"${enable_languages}" = x ||
4812        test x"${enable_languages}" = xyes;
4813        then
4814       echo configure.in: --enable-languages needs at least one language argument 1>&2
4815       exit 1
4816     fi
4817   fi
4818   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4819
4820   # 'f95' is the old name for the 'fortran' language. We issue a warning
4821   # and make the substitution.
4822   case ,${enable_languages}, in
4823     *,f95,*)
4824       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4825       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4826       ;;
4827   esac
4828
4829   # First scan to see if an enabled language requires some other language.
4830   # We assume that a given config-lang.in will list all the language
4831   # front ends it requires, even if some are required indirectly.
4832   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4833     case ${lang_frag} in
4834       ..) ;;
4835       # The odd quoting in the next line works around
4836       # an apparent bug in bash 1.12 on linux.
4837       ${srcdir}/gcc/[*]/config-lang.in) ;;
4838       *)
4839         # From the config-lang.in, get $language, $lang_requires
4840         language=
4841         lang_requires=
4842         . ${lang_frag}
4843         for other in ${lang_requires} ; do
4844           case ,${enable_languages}, in
4845             *,$other,*) ;;
4846             *,all,*) ;;
4847             *,$language,*)
4848               echo " \`$other' language required by \`$language'; enabling" 1>&2
4849               enable_languages="${enable_languages},${other}"
4850               ;;
4851           esac
4852         done
4853         ;;
4854     esac
4855   done
4856
4857   new_enable_languages=,c,
4858   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4859   potential_languages=,c,
4860
4861   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4862     case ${lang_frag} in
4863       ..) ;;
4864       # The odd quoting in the next line works around
4865       # an apparent bug in bash 1.12 on linux.
4866       ${srcdir}/gcc/[*]/config-lang.in) ;;
4867       *)
4868         # From the config-lang.in, get $language, $target_libs,
4869         # $lang_dirs, $boot_language, and $build_by_default
4870         language=
4871         target_libs=
4872         lang_dirs=
4873         subdir_requires=
4874         boot_language=no
4875         build_by_default=yes
4876         . ${lang_frag}
4877         if test x${language} = x; then
4878           echo "${lang_frag} doesn't set \$language." 1>&2
4879           exit 1
4880         fi
4881
4882         case ,${enable_languages}, in
4883           *,${language},*)
4884             # Language was explicitly selected; include it.
4885             add_this_lang=yes
4886             ;;
4887           *,all,*)
4888             # 'all' was selected, select it if it is a default language
4889             add_this_lang=${build_by_default}
4890             ;;
4891           *)
4892             add_this_lang=no
4893             ;;
4894         esac
4895
4896         # Disable languages that need other directories if these aren't available.
4897         for i in $subdir_requires; do
4898           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4899           case ,${enable_languages}, in
4900             *,${language},*)
4901               # Specifically requested language; tell them.
4902               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4903 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4904    { (exit 1); exit 1; }; }
4905               ;;
4906             *)
4907               # Silently disable.
4908               add_this_lang=unsupported
4909               ;;
4910           esac
4911         done
4912
4913         # Disable Ada if no preexisting GNAT is available.
4914         case ,${enable_languages},:${language}:${have_gnat} in
4915           *,${language},*:ada:no)
4916             # Specifically requested language; tell them.
4917             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4918 echo "$as_me: error: GNAT is required to build $language" >&2;}
4919    { (exit 1); exit 1; }; }
4920             ;;
4921           *:ada:no)
4922             # Silently disable.
4923             add_this_lang=unsupported
4924             ;;
4925         esac
4926
4927         # Disable a language that is unsupported by the target.
4928         case " $unsupported_languages " in
4929           *" $language "*)
4930             add_this_lang=unsupported
4931             ;;
4932         esac
4933
4934         case $add_this_lang in
4935           unsupported)
4936             # Remove language-dependent dirs.
4937             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4938             ;;
4939           no)
4940             # Remove language-dependent dirs; still show language as supported.
4941             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4942             potential_languages="${potential_languages}${language},"
4943             ;;
4944           yes)
4945             new_enable_languages="${new_enable_languages}${language},"
4946             potential_languages="${potential_languages}${language},"
4947             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4948             case ${boot_language} in
4949               yes)
4950                 # Add to (comma-separated) list of stage 1 languages.
4951                 stage1_languages="${stage1_languages}${language},"
4952                 ;;
4953             esac
4954             ;;
4955         esac
4956         ;;
4957     esac
4958   done
4959
4960   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4961 if test "${enable_stage1_languages+set}" = set; then
4962   enableval="$enable_stage1_languages"
4963   case ,${enable_stage1_languages}, in
4964     ,no,|,,)
4965       # Set it to something that will have no effect in the loop below
4966       enable_stage1_languages=c ;;
4967     ,yes,)
4968       enable_stage1_languages=`echo $new_enable_languages | \
4969         sed -e "s/^,//" -e "s/,$//" ` ;;
4970     *,all,*)
4971       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4972         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4973   esac
4974
4975   # Add "good" languages from enable_stage1_languages to stage1_languages,
4976   # while "bad" languages go in missing_languages.  Leave no duplicates.
4977   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4978     case $potential_languages in
4979       *,$i,*)
4980         case $stage1_languages in
4981           *,$i,*) ;;
4982           *) stage1_languages="$stage1_languages$i," ;;
4983         esac ;;
4984       *)
4985         case $missing_languages in
4986           *,$i,*) ;;
4987           *) missing_languages="$missing_languages$i," ;;
4988         esac ;;
4989      esac
4990   done
4991 fi;
4992
4993   # Remove leading/trailing commas that were added for simplicity
4994   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4995   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4996   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4997   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4998
4999   if test "x$missing_languages" != x; then
5000     { { echo "$as_me:$LINENO: error:
5001 The following requested languages could not be built: ${missing_languages}
5002 Supported languages are: ${potential_languages}" >&5
5003 echo "$as_me: error:
5004 The following requested languages could not be built: ${missing_languages}
5005 Supported languages are: ${potential_languages}" >&2;}
5006    { (exit 1); exit 1; }; }
5007   fi
5008   if test "x$new_enable_languages" != "x$enable_languages"; then
5009     echo The following languages will be built: ${new_enable_languages}
5010     enable_languages="$new_enable_languages"
5011   fi
5012
5013
5014   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5015 fi
5016
5017 # Handle --disable-<component> generically.
5018 for dir in $configdirs $build_configdirs $target_configdirs ; do
5019   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5020   varname=`echo $dirname | sed -e s/+/_/g`
5021   if eval test x\${enable_${varname}} "=" xno ; then
5022     noconfigdirs="$noconfigdirs $dir"
5023   fi
5024 done
5025
5026 # Check for Boehm's garbage collector
5027 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5028 if test "${enable_objc_gc+set}" = set; then
5029   enableval="$enable_objc_gc"
5030   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5031   *,objc,*:*:yes:*target-boehm-gc*)
5032     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5033 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5034    { (exit 1); exit 1; }; }
5035     ;;
5036 esac
5037 fi;
5038
5039 # Make sure we only build Boehm's garbage collector if required.
5040 case ,${enable_languages},:${enable_objc_gc} in
5041   *,objc,*:yes)
5042     # Keep target-boehm-gc if requested for Objective-C.
5043     ;;
5044   *)
5045     # Otherwise remove target-boehm-gc depending on target-libjava.
5046     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5047       noconfigdirs="$noconfigdirs target-boehm-gc"
5048     fi
5049     ;;
5050 esac
5051
5052 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5053 # $build_configdirs and $target_configdirs.
5054 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5055
5056 notsupp=""
5057 for dir in . $skipdirs $noconfigdirs ; do
5058   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5059   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5060     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5061     if test -r $srcdir/$dirname/configure ; then
5062       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5063         true
5064       else
5065         notsupp="$notsupp $dir"
5066       fi
5067     fi
5068   fi
5069   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5070     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5071     if test -r $srcdir/$dirname/configure ; then
5072       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5073         true
5074       else
5075         notsupp="$notsupp $dir"
5076       fi
5077     fi
5078   fi
5079   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5080     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5081     if test -r $srcdir/$dirname/configure ; then
5082       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5083         true
5084       else
5085         notsupp="$notsupp $dir"
5086       fi
5087     fi
5088   fi
5089 done
5090
5091 # Sometimes the tools are distributed with libiberty but with no other
5092 # libraries.  In that case, we don't want to build target-libiberty.
5093 # Don't let libgcc imply libiberty either.
5094 if test -n "${target_configdirs}" ; then
5095   libgcc=
5096   others=
5097   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5098     if test "$i" = "libgcc"; then
5099       libgcc=target-libgcc
5100     elif test "$i" != "libiberty" ; then
5101       if test -r $srcdir/$i/configure ; then
5102         others=yes;
5103         break;
5104       fi
5105     fi
5106   done
5107   if test -z "${others}" ; then
5108     target_configdirs=$libgcc
5109   fi
5110 fi
5111
5112 # Quietly strip out all directories which aren't configurable in this tree.
5113 # This relies on all configurable subdirectories being autoconfiscated, which
5114 # is now the case.
5115 build_configdirs_all="$build_configdirs"
5116 build_configdirs=
5117 for i in ${build_configdirs_all} ; do
5118   j=`echo $i | sed -e s/build-//g`
5119   if test -f ${srcdir}/$j/configure ; then
5120     build_configdirs="${build_configdirs} $i"
5121   fi
5122 done
5123
5124 configdirs_all="$configdirs"
5125 configdirs=
5126 for i in ${configdirs_all} ; do
5127   if test -f ${srcdir}/$i/configure ; then
5128     configdirs="${configdirs} $i"
5129   fi
5130 done
5131
5132 target_configdirs_all="$target_configdirs"
5133 target_configdirs=
5134 for i in ${target_configdirs_all} ; do
5135   j=`echo $i | sed -e s/target-//g`
5136   if test -f ${srcdir}/$j/configure ; then
5137     target_configdirs="${target_configdirs} $i"
5138   fi
5139 done
5140
5141 # Produce a warning message for the subdirs we can't configure.
5142 # This isn't especially interesting in the Cygnus tree, but in the individual
5143 # FSF releases, it's important to let people know when their machine isn't
5144 # supported by the one or two programs in a package.
5145
5146 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5147   # If $appdirs is non-empty, at least one of those directories must still
5148   # be configured, or we error out.  (E.g., if the gas release supports a
5149   # specified target in some subdirs but not the gas subdir, we shouldn't
5150   # pretend that all is well.)
5151   if test -n "$appdirs" ; then
5152     for dir in $appdirs ; do
5153       if test -r $dir/Makefile.in ; then
5154         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5155           appdirs=""
5156           break
5157         fi
5158         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5159           appdirs=""
5160           break
5161         fi
5162       fi
5163     done
5164     if test -n "$appdirs" ; then
5165       echo "*** This configuration is not supported by this package." 1>&2
5166       exit 1
5167     fi
5168   fi
5169   # Okay, some application will build, or we don't care to check.  Still
5170   # notify of subdirs not getting built.
5171   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5172   echo "    ${notsupp}" 1>&2
5173   echo "    (Any other directories should still work fine.)" 1>&2
5174 fi
5175
5176 case "$host" in
5177   *msdosdjgpp*)
5178     enable_gdbtk=no ;;
5179 esac
5180
5181 # To find our prefix, in gcc_cv_tool_prefix.
5182
5183 # The user is always right.
5184 if test "${PATH_SEPARATOR+set}" != set; then
5185   echo "#! /bin/sh" >conf$$.sh
5186   echo  "exit 0"   >>conf$$.sh
5187   chmod +x conf$$.sh
5188   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5189     PATH_SEPARATOR=';'
5190   else
5191     PATH_SEPARATOR=:
5192   fi
5193   rm -f conf$$.sh
5194 fi
5195
5196
5197
5198 if test "x$exec_prefix" = xNONE; then
5199         if test "x$prefix" = xNONE; then
5200                 gcc_cv_tool_prefix=$ac_default_prefix
5201         else
5202                 gcc_cv_tool_prefix=$prefix
5203         fi
5204 else
5205         gcc_cv_tool_prefix=$exec_prefix
5206 fi
5207
5208 # If there is no compiler in the tree, use the PATH only.  In any
5209 # case, if there is no compiler in the tree nobody should use
5210 # AS_FOR_TARGET and LD_FOR_TARGET.
5211 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5212     gcc_version=`cat $srcdir/gcc/BASE-VER`
5213     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5214     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5215     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5216     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5217     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5218     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5219 else
5220     gcc_cv_tool_dirs=
5221 fi
5222
5223 if test x$build = x$target && test -n "$md_exec_prefix"; then
5224         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5225 fi
5226
5227
5228
5229 copy_dirs=
5230
5231
5232 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5233 if test "${with_build_sysroot+set}" = set; then
5234   withval="$with_build_sysroot"
5235   if test x"$withval" != x ; then
5236      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5237    fi
5238 else
5239   SYSROOT_CFLAGS_FOR_TARGET=
5240 fi;
5241
5242
5243
5244 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5245 if test "${with_debug_prefix_map+set}" = set; then
5246   withval="$with_debug_prefix_map"
5247   if test x"$withval" != x; then
5248      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5249      for debug_map in $withval; do
5250        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5251      done
5252    fi
5253 else
5254   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5255 fi;
5256
5257
5258 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5259 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5260 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5261 # We want to ensure that TARGET libraries (which we know are built with
5262 # gcc) are built with "-O2 -g", so include those options when setting
5263 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5264 if test "x$CFLAGS_FOR_TARGET" = x; then
5265   CFLAGS_FOR_TARGET=$CFLAGS
5266   case " $CFLAGS " in
5267     *" -O2 "*) ;;
5268     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5269   esac
5270   case " $CFLAGS " in
5271     *" -g "* | *" -g3 "*) ;;
5272     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5273   esac
5274 fi
5275
5276
5277 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5278   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5279   case " $CXXFLAGS " in
5280     *" -O2 "*) ;;
5281     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5282   esac
5283   case " $CXXFLAGS " in
5284     *" -g "* | *" -g3 "*) ;;
5285     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5286   esac
5287 fi
5288
5289
5290 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5291 # the named directory are copied to $(tooldir)/sys-include.
5292 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5293   if test x${is_cross_compiler} = xno ; then
5294     echo 1>&2 '***' --with-headers is only supported when cross compiling
5295     exit 1
5296   fi
5297   if test x"${with_headers}" != xyes ; then
5298     x=${gcc_cv_tool_prefix}
5299     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5300   fi
5301 fi
5302
5303 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5304 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5305 # are permitted.
5306 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5307   if test x${is_cross_compiler} = xno ; then
5308     echo 1>&2 '***' --with-libs is only supported when cross compiling
5309     exit 1
5310   fi
5311   if test x"${with_libs}" != xyes ; then
5312     # Copy the libraries in reverse order, so that files in the first named
5313     # library override files in subsequent libraries.
5314     x=${gcc_cv_tool_prefix}
5315     for l in ${with_libs}; do
5316       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5317     done
5318   fi
5319 fi
5320
5321 # Set with_gnu_as and with_gnu_ld as appropriate.
5322 #
5323 # This is done by determining whether or not the appropriate directory
5324 # is available, and by checking whether or not specific configurations
5325 # have requested that this magic not happen.
5326 #
5327 # The command line options always override the explicit settings in
5328 # configure.in, and the settings in configure.in override this magic.
5329 #
5330 # If the default for a toolchain is to use GNU as and ld, and you don't
5331 # want to do that, then you should use the --without-gnu-as and
5332 # --without-gnu-ld options for the configure script.
5333
5334 if test x${use_gnu_as} = x &&
5335    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5336   with_gnu_as=yes
5337   extra_host_args="$extra_host_args --with-gnu-as"
5338 fi
5339
5340 if test x${use_gnu_ld} = x &&
5341    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5342   with_gnu_ld=yes
5343   extra_host_args="$extra_host_args --with-gnu-ld"
5344 fi
5345
5346 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5347 # can detect this case.
5348
5349 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5350   with_newlib=yes
5351   extra_host_args="$extra_host_args --with-newlib"
5352 fi
5353
5354 # Handle ${copy_dirs}
5355 set fnord ${copy_dirs}
5356 shift
5357 while test $# != 0 ; do
5358   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5359     :
5360   else
5361     echo Copying $1 to $2
5362
5363     # Use the install script to create the directory and all required
5364     # parent directories.
5365     if test -d $2 ; then
5366       :
5367     else
5368       echo >config.temp
5369       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5370     fi
5371
5372     # Copy the directory, assuming we have tar.
5373     # FIXME: Should we use B in the second tar?  Not all systems support it.
5374     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5375
5376     # It is the responsibility of the user to correctly adjust all
5377     # symlinks.  If somebody can figure out how to handle them correctly
5378     # here, feel free to add the code.
5379
5380     echo $1 > $2/COPIED
5381   fi
5382   shift; shift
5383 done
5384
5385 # Determine a target-dependent exec_prefix that the installed
5386 # gcc will search in.  Keep this list sorted by triplet, with
5387 # the *-*-osname triplets last.
5388 md_exec_prefix=
5389 case "${target}" in
5390   alpha*-*-*vms*)
5391     md_exec_prefix=/gnu/lib/gcc-lib
5392     ;;
5393   i[34567]86-pc-msdosdjgpp*)
5394     md_exec_prefix=/dev/env/DJDIR/bin
5395     ;;
5396   i[34567]86-*-sco3.2v5*)
5397     if test $with_gnu_as = yes; then
5398       md_exec_prefix=/usr/gnu/bin
5399     else
5400       md_exec_prefix=/usr/ccs/bin/elf
5401     fi
5402     ;;
5403
5404   mn10300-*-* | \
5405   powerpc-*-chorusos* | \
5406   powerpc*-*-eabi* | \
5407   powerpc*-*-sysv* | \
5408   powerpc*-*-kaos* | \
5409   s390x-ibm-tpf*)
5410     md_exec_prefix=/usr/ccs/bin
5411     ;;
5412   sparc64-*-elf*)
5413     ;;
5414   v850*-*-*)
5415     md_exec_prefix=/usr/ccs/bin
5416     ;;
5417   xtensa*-*-elf*)
5418     ;;
5419
5420   *-*-beos* | \
5421   *-*-elf* | \
5422   *-*-hpux* | \
5423   *-*-netware* | \
5424   *-*-nto-qnx* | \
5425   *-*-rtems* | \
5426   *-*-solaris2* | \
5427   *-*-sysv[45]* | \
5428   *-*-vxworks* | \
5429   *-wrs-windiss)
5430     md_exec_prefix=/usr/ccs/bin
5431     ;;
5432 esac
5433
5434 extra_arflags_for_target=
5435 extra_nmflags_for_target=
5436 extra_ranlibflags_for_target=
5437 target_makefile_frag=/dev/null
5438 case "${target}" in
5439   mep*-*-*)
5440     target_makefile_frag="config/mt-mep"
5441     ;;
5442   spu-*-*)
5443     target_makefile_frag="config/mt-spu"
5444     ;;
5445   mips*-sde-elf*)
5446     target_makefile_frag="config/mt-sde"
5447     ;;
5448   mipsisa*-*-elfoabi*)
5449     target_makefile_frag="config/mt-mips-elfoabi"
5450     ;;
5451   mips*-*-*linux* | mips*-*-gnu*)
5452     target_makefile_frag="config/mt-mips-gnu"
5453     ;;
5454   *-*-netware*)
5455     target_makefile_frag="config/mt-netware"
5456     ;;
5457   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5458     target_makefile_frag="config/mt-gnu"
5459     ;;
5460   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5461     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5462     # commands to handle both 32-bit and 64-bit objects.  These flags are
5463     # harmless if we're using GNU nm or ar.
5464     extra_arflags_for_target=" -X32_64"
5465     extra_nmflags_for_target=" -B -X32_64"
5466     ;;
5467   *-*-darwin*)
5468     # ranlib from Darwin requires the -c flag to look at common symbols.
5469     extra_ranlibflags_for_target=" -c"
5470     ;;
5471   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5472     target_makefile_frag="config/mt-wince"
5473     ;;
5474 esac
5475
5476 alphaieee_frag=/dev/null
5477 case $target in
5478   alpha*-*-*)
5479     # This just makes sure to use the -mieee option to build target libs.
5480     # This should probably be set individually by each library.
5481     alphaieee_frag="config/mt-alphaieee"
5482     ;;
5483 esac
5484
5485 # If --enable-target-optspace always use -Os instead of -O2 to build
5486 # the target libraries, similarly if it is not specified, use -Os
5487 # on selected platforms.
5488 ospace_frag=/dev/null
5489 case "${enable_target_optspace}:${target}" in
5490   yes:*)
5491     ospace_frag="config/mt-ospace"
5492     ;;
5493   :d30v-*)
5494     ospace_frag="config/mt-d30v"
5495     ;;
5496   :m32r-* | :d10v-* | :fr30-*)
5497     ospace_frag="config/mt-ospace"
5498     ;;
5499   no:* | :*)
5500     ;;
5501   *)
5502     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5503     ;;
5504 esac
5505
5506 # Default to using --with-stabs for certain targets.
5507 if test x${with_stabs} = x ; then
5508   case "${target}" in
5509   mips*-*-irix[56]*)
5510     ;;
5511   mips*-*-* | alpha*-*-osf*)
5512     with_stabs=yes;
5513     extra_host_args="${extra_host_args} --with-stabs"
5514     ;;
5515   esac
5516 fi
5517
5518 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5519 # them automatically.
5520 case "${host}" in
5521   hppa*64*-*-hpux11*)
5522     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5523     ;;
5524 esac
5525
5526 # Some systems (e.g., one of the i386-aix systems the gas testers are
5527 # using) don't handle "\$" correctly, so don't use it here.
5528 tooldir='${exec_prefix}'/${target_noncanonical}
5529 build_tooldir=${tooldir}
5530
5531 # Create a .gdbinit file which runs the one in srcdir
5532 # and tells GDB to look there for source files.
5533
5534 if test -r ${srcdir}/.gdbinit ; then
5535   case ${srcdir} in
5536     .) ;;
5537     *) cat > ./.gdbinit <<EOF
5538 # ${NO_EDIT}
5539 dir ${srcdir}
5540 dir .
5541 source ${srcdir}/.gdbinit
5542 EOF
5543     ;;
5544   esac
5545 fi
5546
5547 # Make sure that the compiler is able to generate an executable.  If it
5548 # can't, we are probably in trouble.  We don't care whether we can run the
5549 # executable--we might be using a cross compiler--we only care whether it
5550 # can be created.  At this point the main configure script has set CC.
5551 we_are_ok=no
5552 echo "int main () { return 0; }" > conftest.c
5553 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5554 if test $? = 0 ; then
5555   if test -s conftest || test -s conftest.exe ; then
5556     we_are_ok=yes
5557   fi
5558 fi
5559 case $we_are_ok in
5560   no)
5561     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5562     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5563     rm -f conftest*
5564     exit 1
5565     ;;
5566 esac
5567 rm -f conftest*
5568
5569 # The Solaris /usr/ucb/cc compiler does not appear to work.
5570 case "${host}" in
5571   sparc-sun-solaris2*)
5572       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5573       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5574           could_use=
5575           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5576           if test -d /opt/cygnus/bin ; then
5577               if test "$could_use" = "" ; then
5578                   could_use="/opt/cygnus/bin"
5579               else
5580                   could_use="$could_use or /opt/cygnus/bin"
5581               fi
5582           fi
5583         if test "$could_use" = "" ; then
5584             echo "Warning: compilation may fail because you're using"
5585             echo "/usr/ucb/cc.  You should change your PATH or CC "
5586             echo "variable and rerun configure."
5587         else
5588             echo "Warning: compilation may fail because you're using"
5589             echo "/usr/ucb/cc, when you should use the C compiler from"
5590             echo "$could_use.  You should change your"
5591             echo "PATH or CC variable and rerun configure."
5592         fi
5593       fi
5594   ;;
5595 esac
5596
5597 case "${host}" in
5598   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5599   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5600   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5601 esac
5602
5603 # Record target_configdirs and the configure arguments for target and
5604 # build configuration in Makefile.
5605 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5606 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5607
5608 # Determine whether gdb needs tk/tcl or not.
5609 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5610 # and in that case we want gdb to be built without tk.  Ugh!
5611 # In fact I believe gdb is the *only* package directly dependent on tk,
5612 # so we should be able to put the 'maybe's in unconditionally and
5613 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5614 # 100% sure that that's safe though.
5615
5616 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5617 case "$enable_gdbtk" in
5618   no)
5619     GDB_TK="" ;;
5620   yes)
5621     GDB_TK="${gdb_tk}" ;;
5622   *)
5623     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5624     # distro.  Eventually someone will fix this and move Insight, nee
5625     # gdbtk to a separate directory.
5626     if test -d ${srcdir}/gdb/gdbtk ; then
5627       GDB_TK="${gdb_tk}"
5628     else
5629       GDB_TK=""
5630     fi
5631     ;;
5632 esac
5633 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5634 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5635
5636 # Strip out unwanted targets.
5637
5638 # While at that, we remove Makefiles if we were started for recursive
5639 # configuration, so that the top-level Makefile reconfigures them,
5640 # like we used to do when configure itself was recursive.
5641
5642 # Loop over modules.  $extrasub must be used with care, limiting as
5643 # much as possible the usage of range addresses.  That's because autoconf
5644 # splits the sed script to overcome limits in the number of commands,
5645 # and relying on carefully-timed sed passes may turn out to be very hard
5646 # to maintain later.  In this particular case, you just have to be careful
5647 # not to nest @if/@endif pairs, because configure will not warn you at all.
5648
5649 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5650 if test "${enable_bootstrap+set}" = set; then
5651   enableval="$enable_bootstrap"
5652
5653 else
5654   enable_bootstrap=default
5655 fi;
5656
5657 # Issue errors and warnings for invalid/strange bootstrap combinations.
5658 case "$configdirs" in
5659   *gcc*) have_compiler=yes ;;
5660   *) have_compiler=no ;;
5661 esac
5662
5663 case "$have_compiler:$host:$target:$enable_bootstrap" in
5664   *:*:*:no) ;;
5665
5666   # Default behavior.  Enable bootstrap if we have a compiler
5667   # and we are in a native configuration.
5668   yes:$build:$build:default)
5669     enable_bootstrap=yes ;;
5670
5671   *:*:*:default)
5672     enable_bootstrap=no ;;
5673
5674   # We have a compiler and we are in a native configuration, bootstrap is ok
5675   yes:$build:$build:yes)
5676     ;;
5677
5678   # Other configurations, but we have a compiler.  Assume the user knows
5679   # what he's doing.
5680   yes:*:*:yes)
5681     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5682 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5683     ;;
5684
5685   # No compiler: if they passed --enable-bootstrap explicitly, fail
5686   no:*:*:yes)
5687     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5688 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5689    { (exit 1); exit 1; }; } ;;
5690
5691   # Fail if wrong command line
5692   *)
5693     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5694 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5695    { (exit 1); exit 1; }; }
5696     ;;
5697 esac
5698
5699 # Adjust the toplevel makefile according to whether bootstrap was selected.
5700 case "$enable_bootstrap" in
5701   yes)
5702     bootstrap_suffix=bootstrap ;;
5703   no)
5704     bootstrap_suffix=no-bootstrap ;;
5705 esac
5706
5707 for module in ${build_configdirs} ; do
5708   if test -z "${no_recursion}" \
5709      && test -f ${build_subdir}/${module}/Makefile; then
5710     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5711     rm -f ${build_subdir}/${module}/Makefile
5712   fi
5713   extrasub="$extrasub
5714 /^@if build-$module\$/d
5715 /^@endif build-$module\$/d
5716 /^@if build-$module-$bootstrap_suffix\$/d
5717 /^@endif build-$module-$bootstrap_suffix\$/d"
5718 done
5719 for module in ${configdirs} ; do
5720   if test -z "${no_recursion}"; then
5721     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5722       if test -f ${file}; then
5723         echo 1>&2 "*** removing ${file} to force reconfigure"
5724         rm -f ${file}
5725       fi
5726     done
5727   fi
5728   extrasub="$extrasub
5729 /^@if $module\$/d
5730 /^@endif $module\$/d
5731 /^@if $module-$bootstrap_suffix\$/d
5732 /^@endif $module-$bootstrap_suffix\$/d"
5733 done
5734 for module in ${target_configdirs} ; do
5735   if test -z "${no_recursion}" \
5736      && test -f ${target_subdir}/${module}/Makefile; then
5737     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5738     rm -f ${target_subdir}/${module}/Makefile
5739   fi
5740   extrasub="$extrasub
5741 /^@if target-$module\$/d
5742 /^@endif target-$module\$/d
5743 /^@if target-$module-$bootstrap_suffix\$/d
5744 /^@endif target-$module-$bootstrap_suffix\$/d"
5745 done
5746
5747 extrasub="$extrasub
5748 /^@if /,/^@endif /d"
5749
5750 # Create the serialization dependencies.  This uses a temporary file.
5751
5752 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5753 if test "${enable_serial_configure+set}" = set; then
5754   enableval="$enable_serial_configure"
5755
5756 fi;
5757
5758 case ${enable_serial_configure} in
5759   yes)
5760     enable_serial_build_configure=yes
5761     enable_serial_host_configure=yes
5762     enable_serial_target_configure=yes
5763     ;;
5764 esac
5765
5766 # These force 'configure's to be done one at a time, to avoid problems
5767 # with contention over a shared config.cache.
5768 rm -f serdep.tmp
5769 echo '# serdep.tmp' > serdep.tmp
5770 olditem=
5771 test "x${enable_serial_build_configure}" = xyes &&
5772 for item in ${build_configdirs} ; do
5773   case ${olditem} in
5774     "") ;;
5775     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5776   esac
5777   olditem=${item}
5778 done
5779 olditem=
5780 test "x${enable_serial_host_configure}" = xyes &&
5781 for item in ${configdirs} ; do
5782   case ${olditem} in
5783     "") ;;
5784     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5785   esac
5786   olditem=${item}
5787 done
5788 olditem=
5789 test "x${enable_serial_target_configure}" = xyes &&
5790 for item in ${target_configdirs} ; do
5791   case ${olditem} in
5792     "") ;;
5793     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5794   esac
5795   olditem=${item}
5796 done
5797 serialization_dependencies=serdep.tmp
5798
5799
5800 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5801 # target, nonopt, and variable assignments.  These are the ones we
5802 # might not want to pass down to subconfigures.  Also strip
5803 # program-prefix, program-suffix, and program-transform-name, so that
5804 # we can pass down a consistent program-transform-name.
5805 baseargs=
5806 keep_next=no
5807 skip_next=no
5808 eval "set -- $ac_configure_args"
5809 for ac_arg
5810 do
5811   if test X"$skip_next" = X"yes"; then
5812     skip_next=no
5813     continue
5814   fi
5815   if test X"$keep_next" = X"yes"; then
5816     case $ac_arg in
5817       *\'*)
5818         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5819     esac
5820     baseargs="$baseargs '$ac_arg'"
5821     keep_next=no
5822     continue
5823   fi
5824
5825   # Handle separated arguments.  Based on the logic generated by
5826   # autoconf 2.59.
5827   case $ac_arg in
5828     *=* | --config-cache | -C | -disable-* | --disable-* \
5829       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5830       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5831       | -with-* | --with-* | -without-* | --without-* | --x)
5832       separate_arg=no
5833       ;;
5834     -*)
5835       separate_arg=yes
5836       ;;
5837     *)
5838       separate_arg=no
5839       ;;
5840   esac
5841
5842   case "$ac_arg" in
5843     --no*)
5844       continue
5845       ;;
5846     --c* | \
5847     --sr* | \
5848     --ho* | \
5849     --bu* | \
5850     --t* | \
5851     --program-* | \
5852     -cache_file* | \
5853     -srcdir* | \
5854     -host* | \
5855     -build* | \
5856     -target* | \
5857     -program-prefix* | \
5858     -program-suffix* | \
5859     -program-transform-name* )
5860       skip_next=$separate_arg
5861       continue
5862       ;;
5863     -*)
5864       # An option.  Add it.
5865       case $ac_arg in
5866         *\'*)
5867           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5868       esac
5869       baseargs="$baseargs '$ac_arg'"
5870       keep_next=$separate_arg
5871       ;;
5872     *)
5873       # Either a variable assignment, or a nonopt (triplet).  Don't
5874       # pass it down; let the Makefile handle this.
5875       continue
5876       ;;
5877   esac
5878 done
5879 # Remove the initial space we just introduced and, as these will be
5880 # expanded by make, quote '$'.
5881 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5882
5883 # Add in --program-transform-name, after --program-prefix and
5884 # --program-suffix have been applied to it.  Autoconf has already
5885 # doubled dollar signs and backslashes in program_transform_name; we want
5886 # the backslashes un-doubled, and then the entire thing wrapped in single
5887 # quotes, because this will be expanded first by make and then by the shell.
5888 # Also, because we want to override the logic in subdir configure scripts to
5889 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5890 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5891 ${program_transform_name}
5892 EOF_SED
5893 gcc_transform_name=`cat conftestsed.out`
5894 rm -f conftestsed.out
5895 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5896 if test "$silent" = yes; then
5897   baseargs="$baseargs --silent"
5898 fi
5899
5900 # For the build-side libraries, we just need to pretend we're native,
5901 # and not use the same cache file.  Multilibs are neither needed nor
5902 # desired.
5903 build_configargs="--cache-file=../config.cache ${baseargs}"
5904
5905 # For host modules, accept cache file option, or specification as blank.
5906 case "${cache_file}" in
5907 "") # empty
5908   cache_file_option="" ;;
5909 /* | [A-Za-z]:[\\/]* ) # absolute path
5910   cache_file_option="--cache-file=${cache_file}" ;;
5911 *) # relative path
5912   cache_file_option="--cache-file=../${cache_file}" ;;
5913 esac
5914
5915 # Host dirs don't like to share a cache file either, horribly enough.
5916 # This seems to be due to autoconf 2.5x stupidity.
5917 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5918
5919 target_configargs=${baseargs}
5920
5921 # Passing a --with-cross-host argument lets the target libraries know
5922 # whether they are being built with a cross-compiler or being built
5923 # native.  However, it would be better to use other mechanisms to make the
5924 # sorts of decisions they want to make on this basis.  Please consider
5925 # this option to be deprecated.  FIXME.
5926 if test x${is_cross_compiler} = xyes ; then
5927   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5928 fi
5929
5930 # Default to --enable-multilib.
5931 if test x${enable_multilib} = x ; then
5932   target_configargs="--enable-multilib ${target_configargs}"
5933 fi
5934
5935 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5936 # changed from the earlier setting of with_newlib.
5937 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5938   target_configargs="--with-newlib ${target_configargs}"
5939 fi
5940
5941 # Different target subdirs use different values of certain variables
5942 # (notably CXX).  Worse, multilibs use *lots* of different values.
5943 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5944 # it doesn't automatically accept command-line overrides of them.
5945 # This means it's not safe for target subdirs to share a cache file,
5946 # which is disgusting, but there you have it.  Hopefully this can be
5947 # fixed in future.  It's still worthwhile to use a cache file for each
5948 # directory.  I think.
5949
5950 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5951 # We need to pass --target, as newer autoconf's requires consistency
5952 # for target_alias and gcc doesn't manage it consistently.
5953 target_configargs="--cache-file=./config.cache ${target_configargs}"
5954
5955 FLAGS_FOR_TARGET=
5956 case " $target_configdirs " in
5957  *" newlib "*)
5958   case " $target_configargs " in
5959   *" --with-newlib "*)
5960    case "$target" in
5961    *-cygwin*)
5962      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' ;;
5963    esac
5964
5965    # If we're not building GCC, don't discard standard headers.
5966    if test -d ${srcdir}/gcc; then
5967      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5968
5969      if test "${build}" != "${host}"; then
5970        # On Canadian crosses, CC_FOR_TARGET will have already been set
5971        # by `configure', so we won't have an opportunity to add -Bgcc/
5972        # to it.  This is right: we don't want to search that directory
5973        # for binaries, but we want the header files in there, so add
5974        # them explicitly.
5975        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5976
5977        # Someone might think of using the pre-installed headers on
5978        # Canadian crosses, in case the installed compiler is not fully
5979        # compatible with the compiler being built.  In this case, it
5980        # would be better to flag an error than risking having
5981        # incompatible object files being constructed.  We can't
5982        # guarantee that an error will be flagged, but let's hope the
5983        # compiler will do it, when presented with incompatible header
5984        # files.
5985      fi
5986    fi
5987
5988    case "${target}-${is_cross_compiler}" in
5989    i[3456789]86-*-linux*-no)
5990       # Here host == target, so we don't need to build gcc,
5991       # so we don't want to discard standard headers.
5992       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5993       ;;
5994    *)
5995       # If we're building newlib, use its generic headers last, but search
5996       # for any libc-related directories first (so make it the last -B
5997       # switch).
5998       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5999
6000       # If we're building libgloss, find the startup file, simulator library
6001       # and linker script.
6002       case " $target_configdirs " in
6003         *" libgloss "*)
6004         # Look for startup file, simulator library and maybe linker script.
6005         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6006         # Look for libnosys.a in case the target needs it.
6007         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6008         # Most targets have the linker script in the source directory.
6009         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6010         ;;
6011       esac
6012       ;;
6013    esac
6014    ;;
6015   esac
6016   ;;
6017 esac
6018 case "$target" in
6019 *-mingw*)
6020   # Can't be handled as Cygwin above since Mingw does not use newlib.
6021   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' ;;
6022 esac
6023
6024 # Allow the user to override the flags for
6025 # our build compiler if desired.
6026 if test x"${build}" = x"${host}" ; then
6027   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6028   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6029   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6030 fi
6031
6032 # On Canadian crosses, we'll be searching the right directories for
6033 # the previously-installed cross compiler, so don't bother to add
6034 # flags for directories within the install tree of the compiler
6035 # being built; programs in there won't even run.
6036 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6037   # Search for pre-installed headers if nothing else fits.
6038   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6039 fi
6040
6041 if test "x${use_gnu_ld}" = x &&
6042    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6043   # Arrange for us to find uninstalled linker scripts.
6044   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6045 fi
6046
6047 # Search for other target-specific linker scripts and such.
6048 case "${target}" in
6049   mep*)
6050     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6051     ;;
6052 esac
6053
6054 # Makefile fragments.
6055 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6056 do
6057   eval fragval=\$$frag
6058   if test $fragval != /dev/null; then
6059     eval $frag=${srcdir}/$fragval
6060   fi
6061 done
6062
6063
6064
6065
6066
6067 # Miscellanea: directories, flags, etc.
6068
6069
6070
6071
6072
6073
6074
6075 # Build module lists & subconfigure args.
6076
6077
6078
6079 # Host module lists & subconfigure args.
6080
6081
6082
6083 # Target module lists & subconfigure args.
6084
6085
6086
6087 # Build tools.
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105 # Generate default definitions for YACC, M4, LEX and other programs that run
6106 # on the build machine.  These are used if the Makefile can't locate these
6107 # programs in objdir.
6108 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6109
6110 for ac_prog in 'bison -y' byacc yacc
6111 do
6112   # Extract the first word of "$ac_prog", so it can be a program name with args.
6113 set dummy $ac_prog; ac_word=$2
6114 echo "$as_me:$LINENO: checking for $ac_word" >&5
6115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6116 if test "${ac_cv_prog_YACC+set}" = set; then
6117   echo $ECHO_N "(cached) $ECHO_C" >&6
6118 else
6119   if test -n "$YACC"; then
6120   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6121 else
6122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6123 for as_dir in $PATH
6124 do
6125   IFS=$as_save_IFS
6126   test -z "$as_dir" && as_dir=.
6127   for ac_exec_ext in '' $ac_executable_extensions; do
6128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6129     ac_cv_prog_YACC="$ac_prog"
6130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6131     break 2
6132   fi
6133 done
6134 done
6135
6136 fi
6137 fi
6138 YACC=$ac_cv_prog_YACC
6139 if test -n "$YACC"; then
6140   echo "$as_me:$LINENO: result: $YACC" >&5
6141 echo "${ECHO_T}$YACC" >&6
6142 else
6143   echo "$as_me:$LINENO: result: no" >&5
6144 echo "${ECHO_T}no" >&6
6145 fi
6146
6147   test -n "$YACC" && break
6148 done
6149 test -n "$YACC" || YACC="$MISSING bison -y"
6150
6151 case " $build_configdirs " in
6152   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6153   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6154 esac
6155
6156 for ac_prog in bison
6157 do
6158   # Extract the first word of "$ac_prog", so it can be a program name with args.
6159 set dummy $ac_prog; ac_word=$2
6160 echo "$as_me:$LINENO: checking for $ac_word" >&5
6161 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6162 if test "${ac_cv_prog_BISON+set}" = set; then
6163   echo $ECHO_N "(cached) $ECHO_C" >&6
6164 else
6165   if test -n "$BISON"; then
6166   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6167 else
6168 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6169 for as_dir in $PATH
6170 do
6171   IFS=$as_save_IFS
6172   test -z "$as_dir" && as_dir=.
6173   for ac_exec_ext in '' $ac_executable_extensions; do
6174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6175     ac_cv_prog_BISON="$ac_prog"
6176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6177     break 2
6178   fi
6179 done
6180 done
6181
6182 fi
6183 fi
6184 BISON=$ac_cv_prog_BISON
6185 if test -n "$BISON"; then
6186   echo "$as_me:$LINENO: result: $BISON" >&5
6187 echo "${ECHO_T}$BISON" >&6
6188 else
6189   echo "$as_me:$LINENO: result: no" >&5
6190 echo "${ECHO_T}no" >&6
6191 fi
6192
6193   test -n "$BISON" && break
6194 done
6195 test -n "$BISON" || BISON="$MISSING bison"
6196
6197 case " $build_configdirs " in
6198   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6199 esac
6200
6201 for ac_prog in gm4 gnum4 m4
6202 do
6203   # Extract the first word of "$ac_prog", so it can be a program name with args.
6204 set dummy $ac_prog; ac_word=$2
6205 echo "$as_me:$LINENO: checking for $ac_word" >&5
6206 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6207 if test "${ac_cv_prog_M4+set}" = set; then
6208   echo $ECHO_N "(cached) $ECHO_C" >&6
6209 else
6210   if test -n "$M4"; then
6211   ac_cv_prog_M4="$M4" # Let the user override the test.
6212 else
6213 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6214 for as_dir in $PATH
6215 do
6216   IFS=$as_save_IFS
6217   test -z "$as_dir" && as_dir=.
6218   for ac_exec_ext in '' $ac_executable_extensions; do
6219   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6220     ac_cv_prog_M4="$ac_prog"
6221     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6222     break 2
6223   fi
6224 done
6225 done
6226
6227 fi
6228 fi
6229 M4=$ac_cv_prog_M4
6230 if test -n "$M4"; then
6231   echo "$as_me:$LINENO: result: $M4" >&5
6232 echo "${ECHO_T}$M4" >&6
6233 else
6234   echo "$as_me:$LINENO: result: no" >&5
6235 echo "${ECHO_T}no" >&6
6236 fi
6237
6238   test -n "$M4" && break
6239 done
6240 test -n "$M4" || M4="$MISSING m4"
6241
6242 case " $build_configdirs " in
6243   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6244 esac
6245
6246 for ac_prog in flex lex
6247 do
6248   # Extract the first word of "$ac_prog", so it can be a program name with args.
6249 set dummy $ac_prog; ac_word=$2
6250 echo "$as_me:$LINENO: checking for $ac_word" >&5
6251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6252 if test "${ac_cv_prog_LEX+set}" = set; then
6253   echo $ECHO_N "(cached) $ECHO_C" >&6
6254 else
6255   if test -n "$LEX"; then
6256   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6257 else
6258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6259 for as_dir in $PATH
6260 do
6261   IFS=$as_save_IFS
6262   test -z "$as_dir" && as_dir=.
6263   for ac_exec_ext in '' $ac_executable_extensions; do
6264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6265     ac_cv_prog_LEX="$ac_prog"
6266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6267     break 2
6268   fi
6269 done
6270 done
6271
6272 fi
6273 fi
6274 LEX=$ac_cv_prog_LEX
6275 if test -n "$LEX"; then
6276   echo "$as_me:$LINENO: result: $LEX" >&5
6277 echo "${ECHO_T}$LEX" >&6
6278 else
6279   echo "$as_me:$LINENO: result: no" >&5
6280 echo "${ECHO_T}no" >&6
6281 fi
6282
6283   test -n "$LEX" && break
6284 done
6285 test -n "$LEX" || LEX="$MISSING flex"
6286
6287 case " $build_configdirs " in
6288   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6289   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6290 esac
6291
6292 for ac_prog in flex
6293 do
6294   # Extract the first word of "$ac_prog", so it can be a program name with args.
6295 set dummy $ac_prog; ac_word=$2
6296 echo "$as_me:$LINENO: checking for $ac_word" >&5
6297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6298 if test "${ac_cv_prog_FLEX+set}" = set; then
6299   echo $ECHO_N "(cached) $ECHO_C" >&6
6300 else
6301   if test -n "$FLEX"; then
6302   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6303 else
6304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6305 for as_dir in $PATH
6306 do
6307   IFS=$as_save_IFS
6308   test -z "$as_dir" && as_dir=.
6309   for ac_exec_ext in '' $ac_executable_extensions; do
6310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6311     ac_cv_prog_FLEX="$ac_prog"
6312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6313     break 2
6314   fi
6315 done
6316 done
6317
6318 fi
6319 fi
6320 FLEX=$ac_cv_prog_FLEX
6321 if test -n "$FLEX"; then
6322   echo "$as_me:$LINENO: result: $FLEX" >&5
6323 echo "${ECHO_T}$FLEX" >&6
6324 else
6325   echo "$as_me:$LINENO: result: no" >&5
6326 echo "${ECHO_T}no" >&6
6327 fi
6328
6329   test -n "$FLEX" && break
6330 done
6331 test -n "$FLEX" || FLEX="$MISSING flex"
6332
6333 case " $build_configdirs " in
6334   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6335 esac
6336
6337 for ac_prog in makeinfo
6338 do
6339   # Extract the first word of "$ac_prog", so it can be a program name with args.
6340 set dummy $ac_prog; ac_word=$2
6341 echo "$as_me:$LINENO: checking for $ac_word" >&5
6342 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6343 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6344   echo $ECHO_N "(cached) $ECHO_C" >&6
6345 else
6346   if test -n "$MAKEINFO"; then
6347   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6348 else
6349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6350 for as_dir in $PATH
6351 do
6352   IFS=$as_save_IFS
6353   test -z "$as_dir" && as_dir=.
6354   for ac_exec_ext in '' $ac_executable_extensions; do
6355   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6356     ac_cv_prog_MAKEINFO="$ac_prog"
6357     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6358     break 2
6359   fi
6360 done
6361 done
6362
6363 fi
6364 fi
6365 MAKEINFO=$ac_cv_prog_MAKEINFO
6366 if test -n "$MAKEINFO"; then
6367   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6368 echo "${ECHO_T}$MAKEINFO" >&6
6369 else
6370   echo "$as_me:$LINENO: result: no" >&5
6371 echo "${ECHO_T}no" >&6
6372 fi
6373
6374   test -n "$MAKEINFO" && break
6375 done
6376 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6377
6378 case " $build_configdirs " in
6379   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6380   *)
6381
6382     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6383     # higher, else we use the "missing" dummy.
6384     if ${MAKEINFO} --version \
6385        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6386       :
6387     else
6388       MAKEINFO="$MISSING makeinfo"
6389     fi
6390     ;;
6391
6392 esac
6393
6394 # FIXME: expect and dejagnu may become build tools?
6395
6396 for ac_prog in expect
6397 do
6398   # Extract the first word of "$ac_prog", so it can be a program name with args.
6399 set dummy $ac_prog; ac_word=$2
6400 echo "$as_me:$LINENO: checking for $ac_word" >&5
6401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6402 if test "${ac_cv_prog_EXPECT+set}" = set; then
6403   echo $ECHO_N "(cached) $ECHO_C" >&6
6404 else
6405   if test -n "$EXPECT"; then
6406   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6407 else
6408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6409 for as_dir in $PATH
6410 do
6411   IFS=$as_save_IFS
6412   test -z "$as_dir" && as_dir=.
6413   for ac_exec_ext in '' $ac_executable_extensions; do
6414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6415     ac_cv_prog_EXPECT="$ac_prog"
6416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6417     break 2
6418   fi
6419 done
6420 done
6421
6422 fi
6423 fi
6424 EXPECT=$ac_cv_prog_EXPECT
6425 if test -n "$EXPECT"; then
6426   echo "$as_me:$LINENO: result: $EXPECT" >&5
6427 echo "${ECHO_T}$EXPECT" >&6
6428 else
6429   echo "$as_me:$LINENO: result: no" >&5
6430 echo "${ECHO_T}no" >&6
6431 fi
6432
6433   test -n "$EXPECT" && break
6434 done
6435 test -n "$EXPECT" || EXPECT="expect"
6436
6437 case " $configdirs " in
6438   *" expect "*)
6439     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6440     ;;
6441 esac
6442
6443 for ac_prog in runtest
6444 do
6445   # Extract the first word of "$ac_prog", so it can be a program name with args.
6446 set dummy $ac_prog; ac_word=$2
6447 echo "$as_me:$LINENO: checking for $ac_word" >&5
6448 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6449 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6450   echo $ECHO_N "(cached) $ECHO_C" >&6
6451 else
6452   if test -n "$RUNTEST"; then
6453   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6454 else
6455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6456 for as_dir in $PATH
6457 do
6458   IFS=$as_save_IFS
6459   test -z "$as_dir" && as_dir=.
6460   for ac_exec_ext in '' $ac_executable_extensions; do
6461   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6462     ac_cv_prog_RUNTEST="$ac_prog"
6463     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6464     break 2
6465   fi
6466 done
6467 done
6468
6469 fi
6470 fi
6471 RUNTEST=$ac_cv_prog_RUNTEST
6472 if test -n "$RUNTEST"; then
6473   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6474 echo "${ECHO_T}$RUNTEST" >&6
6475 else
6476   echo "$as_me:$LINENO: result: no" >&5
6477 echo "${ECHO_T}no" >&6
6478 fi
6479
6480   test -n "$RUNTEST" && break
6481 done
6482 test -n "$RUNTEST" || RUNTEST="runtest"
6483
6484 case " $configdirs " in
6485   *" dejagnu "*)
6486     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6487     ;;
6488 esac
6489
6490
6491 # Host tools.
6492 ncn_tool_prefix=
6493 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6494 ncn_target_tool_prefix=
6495 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6496
6497
6498
6499 if test -n "$AR"; then
6500   ac_cv_prog_AR=$AR
6501 elif test -n "$ac_cv_prog_AR"; then
6502   AR=$ac_cv_prog_AR
6503 fi
6504
6505 if test -n "$ac_cv_prog_AR"; then
6506   for ncn_progname in ar; do
6507     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6508 set dummy ${ncn_progname}; ac_word=$2
6509 echo "$as_me:$LINENO: checking for $ac_word" >&5
6510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6511 if test "${ac_cv_prog_AR+set}" = set; then
6512   echo $ECHO_N "(cached) $ECHO_C" >&6
6513 else
6514   if test -n "$AR"; then
6515   ac_cv_prog_AR="$AR" # Let the user override the test.
6516 else
6517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6518 for as_dir in $PATH
6519 do
6520   IFS=$as_save_IFS
6521   test -z "$as_dir" && as_dir=.
6522   for ac_exec_ext in '' $ac_executable_extensions; do
6523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6524     ac_cv_prog_AR="${ncn_progname}"
6525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6526     break 2
6527   fi
6528 done
6529 done
6530
6531 fi
6532 fi
6533 AR=$ac_cv_prog_AR
6534 if test -n "$AR"; then
6535   echo "$as_me:$LINENO: result: $AR" >&5
6536 echo "${ECHO_T}$AR" >&6
6537 else
6538   echo "$as_me:$LINENO: result: no" >&5
6539 echo "${ECHO_T}no" >&6
6540 fi
6541
6542   done
6543 fi
6544
6545 for ncn_progname in ar; do
6546   if test -n "$ncn_tool_prefix"; then
6547     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6548 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6549 echo "$as_me:$LINENO: checking for $ac_word" >&5
6550 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6551 if test "${ac_cv_prog_AR+set}" = set; then
6552   echo $ECHO_N "(cached) $ECHO_C" >&6
6553 else
6554   if test -n "$AR"; then
6555   ac_cv_prog_AR="$AR" # Let the user override the test.
6556 else
6557 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6558 for as_dir in $PATH
6559 do
6560   IFS=$as_save_IFS
6561   test -z "$as_dir" && as_dir=.
6562   for ac_exec_ext in '' $ac_executable_extensions; do
6563   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6564     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6565     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6566     break 2
6567   fi
6568 done
6569 done
6570
6571 fi
6572 fi
6573 AR=$ac_cv_prog_AR
6574 if test -n "$AR"; then
6575   echo "$as_me:$LINENO: result: $AR" >&5
6576 echo "${ECHO_T}$AR" >&6
6577 else
6578   echo "$as_me:$LINENO: result: no" >&5
6579 echo "${ECHO_T}no" >&6
6580 fi
6581
6582   fi
6583   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6584     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6585 set dummy ${ncn_progname}; ac_word=$2
6586 echo "$as_me:$LINENO: checking for $ac_word" >&5
6587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6588 if test "${ac_cv_prog_AR+set}" = set; then
6589   echo $ECHO_N "(cached) $ECHO_C" >&6
6590 else
6591   if test -n "$AR"; then
6592   ac_cv_prog_AR="$AR" # Let the user override the test.
6593 else
6594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6595 for as_dir in $PATH
6596 do
6597   IFS=$as_save_IFS
6598   test -z "$as_dir" && as_dir=.
6599   for ac_exec_ext in '' $ac_executable_extensions; do
6600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6601     ac_cv_prog_AR="${ncn_progname}"
6602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6603     break 2
6604   fi
6605 done
6606 done
6607
6608 fi
6609 fi
6610 AR=$ac_cv_prog_AR
6611 if test -n "$AR"; then
6612   echo "$as_me:$LINENO: result: $AR" >&5
6613 echo "${ECHO_T}$AR" >&6
6614 else
6615   echo "$as_me:$LINENO: result: no" >&5
6616 echo "${ECHO_T}no" >&6
6617 fi
6618
6619   fi
6620   test -n "$ac_cv_prog_AR" && break
6621 done
6622
6623 if test -z "$ac_cv_prog_AR" ; then
6624   set dummy ar
6625   if test $build = $host ; then
6626     AR="$2"
6627   else
6628     AR="${ncn_tool_prefix}$2"
6629   fi
6630 fi
6631
6632
6633
6634 if test -n "$AS"; then
6635   ac_cv_prog_AS=$AS
6636 elif test -n "$ac_cv_prog_AS"; then
6637   AS=$ac_cv_prog_AS
6638 fi
6639
6640 if test -n "$ac_cv_prog_AS"; then
6641   for ncn_progname in as; do
6642     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6643 set dummy ${ncn_progname}; ac_word=$2
6644 echo "$as_me:$LINENO: checking for $ac_word" >&5
6645 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6646 if test "${ac_cv_prog_AS+set}" = set; then
6647   echo $ECHO_N "(cached) $ECHO_C" >&6
6648 else
6649   if test -n "$AS"; then
6650   ac_cv_prog_AS="$AS" # Let the user override the test.
6651 else
6652 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6653 for as_dir in $PATH
6654 do
6655   IFS=$as_save_IFS
6656   test -z "$as_dir" && as_dir=.
6657   for ac_exec_ext in '' $ac_executable_extensions; do
6658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6659     ac_cv_prog_AS="${ncn_progname}"
6660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6661     break 2
6662   fi
6663 done
6664 done
6665
6666 fi
6667 fi
6668 AS=$ac_cv_prog_AS
6669 if test -n "$AS"; then
6670   echo "$as_me:$LINENO: result: $AS" >&5
6671 echo "${ECHO_T}$AS" >&6
6672 else
6673   echo "$as_me:$LINENO: result: no" >&5
6674 echo "${ECHO_T}no" >&6
6675 fi
6676
6677   done
6678 fi
6679
6680 for ncn_progname in as; do
6681   if test -n "$ncn_tool_prefix"; then
6682     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6683 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6684 echo "$as_me:$LINENO: checking for $ac_word" >&5
6685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6686 if test "${ac_cv_prog_AS+set}" = set; then
6687   echo $ECHO_N "(cached) $ECHO_C" >&6
6688 else
6689   if test -n "$AS"; then
6690   ac_cv_prog_AS="$AS" # Let the user override the test.
6691 else
6692 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6693 for as_dir in $PATH
6694 do
6695   IFS=$as_save_IFS
6696   test -z "$as_dir" && as_dir=.
6697   for ac_exec_ext in '' $ac_executable_extensions; do
6698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6699     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6701     break 2
6702   fi
6703 done
6704 done
6705
6706 fi
6707 fi
6708 AS=$ac_cv_prog_AS
6709 if test -n "$AS"; then
6710   echo "$as_me:$LINENO: result: $AS" >&5
6711 echo "${ECHO_T}$AS" >&6
6712 else
6713   echo "$as_me:$LINENO: result: no" >&5
6714 echo "${ECHO_T}no" >&6
6715 fi
6716
6717   fi
6718   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6719     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6720 set dummy ${ncn_progname}; ac_word=$2
6721 echo "$as_me:$LINENO: checking for $ac_word" >&5
6722 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6723 if test "${ac_cv_prog_AS+set}" = set; then
6724   echo $ECHO_N "(cached) $ECHO_C" >&6
6725 else
6726   if test -n "$AS"; then
6727   ac_cv_prog_AS="$AS" # Let the user override the test.
6728 else
6729 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6730 for as_dir in $PATH
6731 do
6732   IFS=$as_save_IFS
6733   test -z "$as_dir" && as_dir=.
6734   for ac_exec_ext in '' $ac_executable_extensions; do
6735   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6736     ac_cv_prog_AS="${ncn_progname}"
6737     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6738     break 2
6739   fi
6740 done
6741 done
6742
6743 fi
6744 fi
6745 AS=$ac_cv_prog_AS
6746 if test -n "$AS"; then
6747   echo "$as_me:$LINENO: result: $AS" >&5
6748 echo "${ECHO_T}$AS" >&6
6749 else
6750   echo "$as_me:$LINENO: result: no" >&5
6751 echo "${ECHO_T}no" >&6
6752 fi
6753
6754   fi
6755   test -n "$ac_cv_prog_AS" && break
6756 done
6757
6758 if test -z "$ac_cv_prog_AS" ; then
6759   set dummy as
6760   if test $build = $host ; then
6761     AS="$2"
6762   else
6763     AS="${ncn_tool_prefix}$2"
6764   fi
6765 fi
6766
6767
6768
6769 if test -n "$DLLTOOL"; then
6770   ac_cv_prog_DLLTOOL=$DLLTOOL
6771 elif test -n "$ac_cv_prog_DLLTOOL"; then
6772   DLLTOOL=$ac_cv_prog_DLLTOOL
6773 fi
6774
6775 if test -n "$ac_cv_prog_DLLTOOL"; then
6776   for ncn_progname in dlltool; do
6777     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6778 set dummy ${ncn_progname}; ac_word=$2
6779 echo "$as_me:$LINENO: checking for $ac_word" >&5
6780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6781 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6782   echo $ECHO_N "(cached) $ECHO_C" >&6
6783 else
6784   if test -n "$DLLTOOL"; then
6785   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6786 else
6787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6788 for as_dir in $PATH
6789 do
6790   IFS=$as_save_IFS
6791   test -z "$as_dir" && as_dir=.
6792   for ac_exec_ext in '' $ac_executable_extensions; do
6793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6794     ac_cv_prog_DLLTOOL="${ncn_progname}"
6795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6796     break 2
6797   fi
6798 done
6799 done
6800
6801 fi
6802 fi
6803 DLLTOOL=$ac_cv_prog_DLLTOOL
6804 if test -n "$DLLTOOL"; then
6805   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6806 echo "${ECHO_T}$DLLTOOL" >&6
6807 else
6808   echo "$as_me:$LINENO: result: no" >&5
6809 echo "${ECHO_T}no" >&6
6810 fi
6811
6812   done
6813 fi
6814
6815 for ncn_progname in dlltool; do
6816   if test -n "$ncn_tool_prefix"; then
6817     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6818 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6819 echo "$as_me:$LINENO: checking for $ac_word" >&5
6820 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6821 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6822   echo $ECHO_N "(cached) $ECHO_C" >&6
6823 else
6824   if test -n "$DLLTOOL"; then
6825   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6826 else
6827 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6828 for as_dir in $PATH
6829 do
6830   IFS=$as_save_IFS
6831   test -z "$as_dir" && as_dir=.
6832   for ac_exec_ext in '' $ac_executable_extensions; do
6833   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6834     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6835     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6836     break 2
6837   fi
6838 done
6839 done
6840
6841 fi
6842 fi
6843 DLLTOOL=$ac_cv_prog_DLLTOOL
6844 if test -n "$DLLTOOL"; then
6845   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6846 echo "${ECHO_T}$DLLTOOL" >&6
6847 else
6848   echo "$as_me:$LINENO: result: no" >&5
6849 echo "${ECHO_T}no" >&6
6850 fi
6851
6852   fi
6853   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6854     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6855 set dummy ${ncn_progname}; ac_word=$2
6856 echo "$as_me:$LINENO: checking for $ac_word" >&5
6857 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6858 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6859   echo $ECHO_N "(cached) $ECHO_C" >&6
6860 else
6861   if test -n "$DLLTOOL"; then
6862   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6863 else
6864 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6865 for as_dir in $PATH
6866 do
6867   IFS=$as_save_IFS
6868   test -z "$as_dir" && as_dir=.
6869   for ac_exec_ext in '' $ac_executable_extensions; do
6870   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6871     ac_cv_prog_DLLTOOL="${ncn_progname}"
6872     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6873     break 2
6874   fi
6875 done
6876 done
6877
6878 fi
6879 fi
6880 DLLTOOL=$ac_cv_prog_DLLTOOL
6881 if test -n "$DLLTOOL"; then
6882   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6883 echo "${ECHO_T}$DLLTOOL" >&6
6884 else
6885   echo "$as_me:$LINENO: result: no" >&5
6886 echo "${ECHO_T}no" >&6
6887 fi
6888
6889   fi
6890   test -n "$ac_cv_prog_DLLTOOL" && break
6891 done
6892
6893 if test -z "$ac_cv_prog_DLLTOOL" ; then
6894   set dummy dlltool
6895   if test $build = $host ; then
6896     DLLTOOL="$2"
6897   else
6898     DLLTOOL="${ncn_tool_prefix}$2"
6899   fi
6900 fi
6901
6902
6903
6904 if test -n "$LD"; then
6905   ac_cv_prog_LD=$LD
6906 elif test -n "$ac_cv_prog_LD"; then
6907   LD=$ac_cv_prog_LD
6908 fi
6909
6910 if test -n "$ac_cv_prog_LD"; then
6911   for ncn_progname in ld; do
6912     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6913 set dummy ${ncn_progname}; ac_word=$2
6914 echo "$as_me:$LINENO: checking for $ac_word" >&5
6915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6916 if test "${ac_cv_prog_LD+set}" = set; then
6917   echo $ECHO_N "(cached) $ECHO_C" >&6
6918 else
6919   if test -n "$LD"; then
6920   ac_cv_prog_LD="$LD" # Let the user override the test.
6921 else
6922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6923 for as_dir in $PATH
6924 do
6925   IFS=$as_save_IFS
6926   test -z "$as_dir" && as_dir=.
6927   for ac_exec_ext in '' $ac_executable_extensions; do
6928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6929     ac_cv_prog_LD="${ncn_progname}"
6930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6931     break 2
6932   fi
6933 done
6934 done
6935
6936 fi
6937 fi
6938 LD=$ac_cv_prog_LD
6939 if test -n "$LD"; then
6940   echo "$as_me:$LINENO: result: $LD" >&5
6941 echo "${ECHO_T}$LD" >&6
6942 else
6943   echo "$as_me:$LINENO: result: no" >&5
6944 echo "${ECHO_T}no" >&6
6945 fi
6946
6947   done
6948 fi
6949
6950 for ncn_progname in ld; do
6951   if test -n "$ncn_tool_prefix"; then
6952     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6953 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6954 echo "$as_me:$LINENO: checking for $ac_word" >&5
6955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6956 if test "${ac_cv_prog_LD+set}" = set; then
6957   echo $ECHO_N "(cached) $ECHO_C" >&6
6958 else
6959   if test -n "$LD"; then
6960   ac_cv_prog_LD="$LD" # Let the user override the test.
6961 else
6962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6963 for as_dir in $PATH
6964 do
6965   IFS=$as_save_IFS
6966   test -z "$as_dir" && as_dir=.
6967   for ac_exec_ext in '' $ac_executable_extensions; do
6968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6969     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6971     break 2
6972   fi
6973 done
6974 done
6975
6976 fi
6977 fi
6978 LD=$ac_cv_prog_LD
6979 if test -n "$LD"; then
6980   echo "$as_me:$LINENO: result: $LD" >&5
6981 echo "${ECHO_T}$LD" >&6
6982 else
6983   echo "$as_me:$LINENO: result: no" >&5
6984 echo "${ECHO_T}no" >&6
6985 fi
6986
6987   fi
6988   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6989     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6990 set dummy ${ncn_progname}; ac_word=$2
6991 echo "$as_me:$LINENO: checking for $ac_word" >&5
6992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6993 if test "${ac_cv_prog_LD+set}" = set; then
6994   echo $ECHO_N "(cached) $ECHO_C" >&6
6995 else
6996   if test -n "$LD"; then
6997   ac_cv_prog_LD="$LD" # Let the user override the test.
6998 else
6999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7000 for as_dir in $PATH
7001 do
7002   IFS=$as_save_IFS
7003   test -z "$as_dir" && as_dir=.
7004   for ac_exec_ext in '' $ac_executable_extensions; do
7005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7006     ac_cv_prog_LD="${ncn_progname}"
7007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7008     break 2
7009   fi
7010 done
7011 done
7012
7013 fi
7014 fi
7015 LD=$ac_cv_prog_LD
7016 if test -n "$LD"; then
7017   echo "$as_me:$LINENO: result: $LD" >&5
7018 echo "${ECHO_T}$LD" >&6
7019 else
7020   echo "$as_me:$LINENO: result: no" >&5
7021 echo "${ECHO_T}no" >&6
7022 fi
7023
7024   fi
7025   test -n "$ac_cv_prog_LD" && break
7026 done
7027
7028 if test -z "$ac_cv_prog_LD" ; then
7029   set dummy ld
7030   if test $build = $host ; then
7031     LD="$2"
7032   else
7033     LD="${ncn_tool_prefix}$2"
7034   fi
7035 fi
7036
7037
7038
7039 if test -n "$LIPO"; then
7040   ac_cv_prog_LIPO=$LIPO
7041 elif test -n "$ac_cv_prog_LIPO"; then
7042   LIPO=$ac_cv_prog_LIPO
7043 fi
7044
7045 if test -n "$ac_cv_prog_LIPO"; then
7046   for ncn_progname in lipo; do
7047     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7048 set dummy ${ncn_progname}; ac_word=$2
7049 echo "$as_me:$LINENO: checking for $ac_word" >&5
7050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7051 if test "${ac_cv_prog_LIPO+set}" = set; then
7052   echo $ECHO_N "(cached) $ECHO_C" >&6
7053 else
7054   if test -n "$LIPO"; then
7055   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7056 else
7057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7058 for as_dir in $PATH
7059 do
7060   IFS=$as_save_IFS
7061   test -z "$as_dir" && as_dir=.
7062   for ac_exec_ext in '' $ac_executable_extensions; do
7063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7064     ac_cv_prog_LIPO="${ncn_progname}"
7065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7066     break 2
7067   fi
7068 done
7069 done
7070
7071 fi
7072 fi
7073 LIPO=$ac_cv_prog_LIPO
7074 if test -n "$LIPO"; then
7075   echo "$as_me:$LINENO: result: $LIPO" >&5
7076 echo "${ECHO_T}$LIPO" >&6
7077 else
7078   echo "$as_me:$LINENO: result: no" >&5
7079 echo "${ECHO_T}no" >&6
7080 fi
7081
7082   done
7083 fi
7084
7085 for ncn_progname in lipo; do
7086   if test -n "$ncn_tool_prefix"; then
7087     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7088 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7089 echo "$as_me:$LINENO: checking for $ac_word" >&5
7090 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7091 if test "${ac_cv_prog_LIPO+set}" = set; then
7092   echo $ECHO_N "(cached) $ECHO_C" >&6
7093 else
7094   if test -n "$LIPO"; then
7095   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7096 else
7097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7098 for as_dir in $PATH
7099 do
7100   IFS=$as_save_IFS
7101   test -z "$as_dir" && as_dir=.
7102   for ac_exec_ext in '' $ac_executable_extensions; do
7103   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7104     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7105     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7106     break 2
7107   fi
7108 done
7109 done
7110
7111 fi
7112 fi
7113 LIPO=$ac_cv_prog_LIPO
7114 if test -n "$LIPO"; then
7115   echo "$as_me:$LINENO: result: $LIPO" >&5
7116 echo "${ECHO_T}$LIPO" >&6
7117 else
7118   echo "$as_me:$LINENO: result: no" >&5
7119 echo "${ECHO_T}no" >&6
7120 fi
7121
7122   fi
7123   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7124     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7125 set dummy ${ncn_progname}; ac_word=$2
7126 echo "$as_me:$LINENO: checking for $ac_word" >&5
7127 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7128 if test "${ac_cv_prog_LIPO+set}" = set; then
7129   echo $ECHO_N "(cached) $ECHO_C" >&6
7130 else
7131   if test -n "$LIPO"; then
7132   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7133 else
7134 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7135 for as_dir in $PATH
7136 do
7137   IFS=$as_save_IFS
7138   test -z "$as_dir" && as_dir=.
7139   for ac_exec_ext in '' $ac_executable_extensions; do
7140   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7141     ac_cv_prog_LIPO="${ncn_progname}"
7142     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7143     break 2
7144   fi
7145 done
7146 done
7147
7148 fi
7149 fi
7150 LIPO=$ac_cv_prog_LIPO
7151 if test -n "$LIPO"; then
7152   echo "$as_me:$LINENO: result: $LIPO" >&5
7153 echo "${ECHO_T}$LIPO" >&6
7154 else
7155   echo "$as_me:$LINENO: result: no" >&5
7156 echo "${ECHO_T}no" >&6
7157 fi
7158
7159   fi
7160   test -n "$ac_cv_prog_LIPO" && break
7161 done
7162
7163 if test -z "$ac_cv_prog_LIPO" ; then
7164   set dummy lipo
7165   if test $build = $host ; then
7166     LIPO="$2"
7167   else
7168     LIPO="${ncn_tool_prefix}$2"
7169   fi
7170 fi
7171
7172
7173
7174 if test -n "$NM"; then
7175   ac_cv_prog_NM=$NM
7176 elif test -n "$ac_cv_prog_NM"; then
7177   NM=$ac_cv_prog_NM
7178 fi
7179
7180 if test -n "$ac_cv_prog_NM"; then
7181   for ncn_progname in nm; do
7182     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7183 set dummy ${ncn_progname}; ac_word=$2
7184 echo "$as_me:$LINENO: checking for $ac_word" >&5
7185 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7186 if test "${ac_cv_prog_NM+set}" = set; then
7187   echo $ECHO_N "(cached) $ECHO_C" >&6
7188 else
7189   if test -n "$NM"; then
7190   ac_cv_prog_NM="$NM" # Let the user override the test.
7191 else
7192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7193 for as_dir in $PATH
7194 do
7195   IFS=$as_save_IFS
7196   test -z "$as_dir" && as_dir=.
7197   for ac_exec_ext in '' $ac_executable_extensions; do
7198   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7199     ac_cv_prog_NM="${ncn_progname}"
7200     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7201     break 2
7202   fi
7203 done
7204 done
7205
7206 fi
7207 fi
7208 NM=$ac_cv_prog_NM
7209 if test -n "$NM"; then
7210   echo "$as_me:$LINENO: result: $NM" >&5
7211 echo "${ECHO_T}$NM" >&6
7212 else
7213   echo "$as_me:$LINENO: result: no" >&5
7214 echo "${ECHO_T}no" >&6
7215 fi
7216
7217   done
7218 fi
7219
7220 for ncn_progname in nm; do
7221   if test -n "$ncn_tool_prefix"; then
7222     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7223 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7224 echo "$as_me:$LINENO: checking for $ac_word" >&5
7225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7226 if test "${ac_cv_prog_NM+set}" = set; then
7227   echo $ECHO_N "(cached) $ECHO_C" >&6
7228 else
7229   if test -n "$NM"; then
7230   ac_cv_prog_NM="$NM" # Let the user override the test.
7231 else
7232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7233 for as_dir in $PATH
7234 do
7235   IFS=$as_save_IFS
7236   test -z "$as_dir" && as_dir=.
7237   for ac_exec_ext in '' $ac_executable_extensions; do
7238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7239     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7241     break 2
7242   fi
7243 done
7244 done
7245
7246 fi
7247 fi
7248 NM=$ac_cv_prog_NM
7249 if test -n "$NM"; then
7250   echo "$as_me:$LINENO: result: $NM" >&5
7251 echo "${ECHO_T}$NM" >&6
7252 else
7253   echo "$as_me:$LINENO: result: no" >&5
7254 echo "${ECHO_T}no" >&6
7255 fi
7256
7257   fi
7258   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7259     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7260 set dummy ${ncn_progname}; ac_word=$2
7261 echo "$as_me:$LINENO: checking for $ac_word" >&5
7262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7263 if test "${ac_cv_prog_NM+set}" = set; then
7264   echo $ECHO_N "(cached) $ECHO_C" >&6
7265 else
7266   if test -n "$NM"; then
7267   ac_cv_prog_NM="$NM" # Let the user override the test.
7268 else
7269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7270 for as_dir in $PATH
7271 do
7272   IFS=$as_save_IFS
7273   test -z "$as_dir" && as_dir=.
7274   for ac_exec_ext in '' $ac_executable_extensions; do
7275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7276     ac_cv_prog_NM="${ncn_progname}"
7277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7278     break 2
7279   fi
7280 done
7281 done
7282
7283 fi
7284 fi
7285 NM=$ac_cv_prog_NM
7286 if test -n "$NM"; then
7287   echo "$as_me:$LINENO: result: $NM" >&5
7288 echo "${ECHO_T}$NM" >&6
7289 else
7290   echo "$as_me:$LINENO: result: no" >&5
7291 echo "${ECHO_T}no" >&6
7292 fi
7293
7294   fi
7295   test -n "$ac_cv_prog_NM" && break
7296 done
7297
7298 if test -z "$ac_cv_prog_NM" ; then
7299   set dummy nm
7300   if test $build = $host ; then
7301     NM="$2"
7302   else
7303     NM="${ncn_tool_prefix}$2"
7304   fi
7305 fi
7306
7307
7308
7309 if test -n "$RANLIB"; then
7310   ac_cv_prog_RANLIB=$RANLIB
7311 elif test -n "$ac_cv_prog_RANLIB"; then
7312   RANLIB=$ac_cv_prog_RANLIB
7313 fi
7314
7315 if test -n "$ac_cv_prog_RANLIB"; then
7316   for ncn_progname in ranlib; do
7317     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7318 set dummy ${ncn_progname}; ac_word=$2
7319 echo "$as_me:$LINENO: checking for $ac_word" >&5
7320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7321 if test "${ac_cv_prog_RANLIB+set}" = set; then
7322   echo $ECHO_N "(cached) $ECHO_C" >&6
7323 else
7324   if test -n "$RANLIB"; then
7325   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7326 else
7327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7328 for as_dir in $PATH
7329 do
7330   IFS=$as_save_IFS
7331   test -z "$as_dir" && as_dir=.
7332   for ac_exec_ext in '' $ac_executable_extensions; do
7333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7334     ac_cv_prog_RANLIB="${ncn_progname}"
7335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7336     break 2
7337   fi
7338 done
7339 done
7340
7341 fi
7342 fi
7343 RANLIB=$ac_cv_prog_RANLIB
7344 if test -n "$RANLIB"; then
7345   echo "$as_me:$LINENO: result: $RANLIB" >&5
7346 echo "${ECHO_T}$RANLIB" >&6
7347 else
7348   echo "$as_me:$LINENO: result: no" >&5
7349 echo "${ECHO_T}no" >&6
7350 fi
7351
7352   done
7353 fi
7354
7355 for ncn_progname in ranlib; do
7356   if test -n "$ncn_tool_prefix"; then
7357     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7358 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7359 echo "$as_me:$LINENO: checking for $ac_word" >&5
7360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7361 if test "${ac_cv_prog_RANLIB+set}" = set; then
7362   echo $ECHO_N "(cached) $ECHO_C" >&6
7363 else
7364   if test -n "$RANLIB"; then
7365   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7366 else
7367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7368 for as_dir in $PATH
7369 do
7370   IFS=$as_save_IFS
7371   test -z "$as_dir" && as_dir=.
7372   for ac_exec_ext in '' $ac_executable_extensions; do
7373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7374     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7376     break 2
7377   fi
7378 done
7379 done
7380
7381 fi
7382 fi
7383 RANLIB=$ac_cv_prog_RANLIB
7384 if test -n "$RANLIB"; then
7385   echo "$as_me:$LINENO: result: $RANLIB" >&5
7386 echo "${ECHO_T}$RANLIB" >&6
7387 else
7388   echo "$as_me:$LINENO: result: no" >&5
7389 echo "${ECHO_T}no" >&6
7390 fi
7391
7392   fi
7393   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7394     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7395 set dummy ${ncn_progname}; ac_word=$2
7396 echo "$as_me:$LINENO: checking for $ac_word" >&5
7397 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7398 if test "${ac_cv_prog_RANLIB+set}" = set; then
7399   echo $ECHO_N "(cached) $ECHO_C" >&6
7400 else
7401   if test -n "$RANLIB"; then
7402   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7403 else
7404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7405 for as_dir in $PATH
7406 do
7407   IFS=$as_save_IFS
7408   test -z "$as_dir" && as_dir=.
7409   for ac_exec_ext in '' $ac_executable_extensions; do
7410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7411     ac_cv_prog_RANLIB="${ncn_progname}"
7412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7413     break 2
7414   fi
7415 done
7416 done
7417
7418 fi
7419 fi
7420 RANLIB=$ac_cv_prog_RANLIB
7421 if test -n "$RANLIB"; then
7422   echo "$as_me:$LINENO: result: $RANLIB" >&5
7423 echo "${ECHO_T}$RANLIB" >&6
7424 else
7425   echo "$as_me:$LINENO: result: no" >&5
7426 echo "${ECHO_T}no" >&6
7427 fi
7428
7429   fi
7430   test -n "$ac_cv_prog_RANLIB" && break
7431 done
7432
7433 if test -z "$ac_cv_prog_RANLIB" ; then
7434   RANLIB=":"
7435 fi
7436
7437
7438
7439 if test -n "$STRIP"; then
7440   ac_cv_prog_STRIP=$STRIP
7441 elif test -n "$ac_cv_prog_STRIP"; then
7442   STRIP=$ac_cv_prog_STRIP
7443 fi
7444
7445 if test -n "$ac_cv_prog_STRIP"; then
7446   for ncn_progname in strip; do
7447     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7448 set dummy ${ncn_progname}; ac_word=$2
7449 echo "$as_me:$LINENO: checking for $ac_word" >&5
7450 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7451 if test "${ac_cv_prog_STRIP+set}" = set; then
7452   echo $ECHO_N "(cached) $ECHO_C" >&6
7453 else
7454   if test -n "$STRIP"; then
7455   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7456 else
7457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7458 for as_dir in $PATH
7459 do
7460   IFS=$as_save_IFS
7461   test -z "$as_dir" && as_dir=.
7462   for ac_exec_ext in '' $ac_executable_extensions; do
7463   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7464     ac_cv_prog_STRIP="${ncn_progname}"
7465     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7466     break 2
7467   fi
7468 done
7469 done
7470
7471 fi
7472 fi
7473 STRIP=$ac_cv_prog_STRIP
7474 if test -n "$STRIP"; then
7475   echo "$as_me:$LINENO: result: $STRIP" >&5
7476 echo "${ECHO_T}$STRIP" >&6
7477 else
7478   echo "$as_me:$LINENO: result: no" >&5
7479 echo "${ECHO_T}no" >&6
7480 fi
7481
7482   done
7483 fi
7484
7485 for ncn_progname in strip; do
7486   if test -n "$ncn_tool_prefix"; then
7487     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7488 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7489 echo "$as_me:$LINENO: checking for $ac_word" >&5
7490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7491 if test "${ac_cv_prog_STRIP+set}" = set; then
7492   echo $ECHO_N "(cached) $ECHO_C" >&6
7493 else
7494   if test -n "$STRIP"; then
7495   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7496 else
7497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7498 for as_dir in $PATH
7499 do
7500   IFS=$as_save_IFS
7501   test -z "$as_dir" && as_dir=.
7502   for ac_exec_ext in '' $ac_executable_extensions; do
7503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7504     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7506     break 2
7507   fi
7508 done
7509 done
7510
7511 fi
7512 fi
7513 STRIP=$ac_cv_prog_STRIP
7514 if test -n "$STRIP"; then
7515   echo "$as_me:$LINENO: result: $STRIP" >&5
7516 echo "${ECHO_T}$STRIP" >&6
7517 else
7518   echo "$as_me:$LINENO: result: no" >&5
7519 echo "${ECHO_T}no" >&6
7520 fi
7521
7522   fi
7523   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7524     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7525 set dummy ${ncn_progname}; ac_word=$2
7526 echo "$as_me:$LINENO: checking for $ac_word" >&5
7527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7528 if test "${ac_cv_prog_STRIP+set}" = set; then
7529   echo $ECHO_N "(cached) $ECHO_C" >&6
7530 else
7531   if test -n "$STRIP"; then
7532   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7533 else
7534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7535 for as_dir in $PATH
7536 do
7537   IFS=$as_save_IFS
7538   test -z "$as_dir" && as_dir=.
7539   for ac_exec_ext in '' $ac_executable_extensions; do
7540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7541     ac_cv_prog_STRIP="${ncn_progname}"
7542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7543     break 2
7544   fi
7545 done
7546 done
7547
7548 fi
7549 fi
7550 STRIP=$ac_cv_prog_STRIP
7551 if test -n "$STRIP"; then
7552   echo "$as_me:$LINENO: result: $STRIP" >&5
7553 echo "${ECHO_T}$STRIP" >&6
7554 else
7555   echo "$as_me:$LINENO: result: no" >&5
7556 echo "${ECHO_T}no" >&6
7557 fi
7558
7559   fi
7560   test -n "$ac_cv_prog_STRIP" && break
7561 done
7562
7563 if test -z "$ac_cv_prog_STRIP" ; then
7564   STRIP=":"
7565 fi
7566
7567
7568
7569 if test -n "$WINDRES"; then
7570   ac_cv_prog_WINDRES=$WINDRES
7571 elif test -n "$ac_cv_prog_WINDRES"; then
7572   WINDRES=$ac_cv_prog_WINDRES
7573 fi
7574
7575 if test -n "$ac_cv_prog_WINDRES"; then
7576   for ncn_progname in windres; do
7577     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7578 set dummy ${ncn_progname}; ac_word=$2
7579 echo "$as_me:$LINENO: checking for $ac_word" >&5
7580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7581 if test "${ac_cv_prog_WINDRES+set}" = set; then
7582   echo $ECHO_N "(cached) $ECHO_C" >&6
7583 else
7584   if test -n "$WINDRES"; then
7585   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7586 else
7587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7588 for as_dir in $PATH
7589 do
7590   IFS=$as_save_IFS
7591   test -z "$as_dir" && as_dir=.
7592   for ac_exec_ext in '' $ac_executable_extensions; do
7593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7594     ac_cv_prog_WINDRES="${ncn_progname}"
7595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7596     break 2
7597   fi
7598 done
7599 done
7600
7601 fi
7602 fi
7603 WINDRES=$ac_cv_prog_WINDRES
7604 if test -n "$WINDRES"; then
7605   echo "$as_me:$LINENO: result: $WINDRES" >&5
7606 echo "${ECHO_T}$WINDRES" >&6
7607 else
7608   echo "$as_me:$LINENO: result: no" >&5
7609 echo "${ECHO_T}no" >&6
7610 fi
7611
7612   done
7613 fi
7614
7615 for ncn_progname in windres; do
7616   if test -n "$ncn_tool_prefix"; then
7617     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7618 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7619 echo "$as_me:$LINENO: checking for $ac_word" >&5
7620 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7621 if test "${ac_cv_prog_WINDRES+set}" = set; then
7622   echo $ECHO_N "(cached) $ECHO_C" >&6
7623 else
7624   if test -n "$WINDRES"; then
7625   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7626 else
7627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7628 for as_dir in $PATH
7629 do
7630   IFS=$as_save_IFS
7631   test -z "$as_dir" && as_dir=.
7632   for ac_exec_ext in '' $ac_executable_extensions; do
7633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7634     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7636     break 2
7637   fi
7638 done
7639 done
7640
7641 fi
7642 fi
7643 WINDRES=$ac_cv_prog_WINDRES
7644 if test -n "$WINDRES"; then
7645   echo "$as_me:$LINENO: result: $WINDRES" >&5
7646 echo "${ECHO_T}$WINDRES" >&6
7647 else
7648   echo "$as_me:$LINENO: result: no" >&5
7649 echo "${ECHO_T}no" >&6
7650 fi
7651
7652   fi
7653   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7654     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7655 set dummy ${ncn_progname}; ac_word=$2
7656 echo "$as_me:$LINENO: checking for $ac_word" >&5
7657 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7658 if test "${ac_cv_prog_WINDRES+set}" = set; then
7659   echo $ECHO_N "(cached) $ECHO_C" >&6
7660 else
7661   if test -n "$WINDRES"; then
7662   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7663 else
7664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7665 for as_dir in $PATH
7666 do
7667   IFS=$as_save_IFS
7668   test -z "$as_dir" && as_dir=.
7669   for ac_exec_ext in '' $ac_executable_extensions; do
7670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7671     ac_cv_prog_WINDRES="${ncn_progname}"
7672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7673     break 2
7674   fi
7675 done
7676 done
7677
7678 fi
7679 fi
7680 WINDRES=$ac_cv_prog_WINDRES
7681 if test -n "$WINDRES"; then
7682   echo "$as_me:$LINENO: result: $WINDRES" >&5
7683 echo "${ECHO_T}$WINDRES" >&6
7684 else
7685   echo "$as_me:$LINENO: result: no" >&5
7686 echo "${ECHO_T}no" >&6
7687 fi
7688
7689   fi
7690   test -n "$ac_cv_prog_WINDRES" && break
7691 done
7692
7693 if test -z "$ac_cv_prog_WINDRES" ; then
7694   set dummy windres
7695   if test $build = $host ; then
7696     WINDRES="$2"
7697   else
7698     WINDRES="${ncn_tool_prefix}$2"
7699   fi
7700 fi
7701
7702
7703
7704 if test -n "$WINDMC"; then
7705   ac_cv_prog_WINDMC=$WINDMC
7706 elif test -n "$ac_cv_prog_WINDMC"; then
7707   WINDMC=$ac_cv_prog_WINDMC
7708 fi
7709
7710 if test -n "$ac_cv_prog_WINDMC"; then
7711   for ncn_progname in windmc; do
7712     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7713 set dummy ${ncn_progname}; ac_word=$2
7714 echo "$as_me:$LINENO: checking for $ac_word" >&5
7715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7716 if test "${ac_cv_prog_WINDMC+set}" = set; then
7717   echo $ECHO_N "(cached) $ECHO_C" >&6
7718 else
7719   if test -n "$WINDMC"; then
7720   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7721 else
7722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7723 for as_dir in $PATH
7724 do
7725   IFS=$as_save_IFS
7726   test -z "$as_dir" && as_dir=.
7727   for ac_exec_ext in '' $ac_executable_extensions; do
7728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7729     ac_cv_prog_WINDMC="${ncn_progname}"
7730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7731     break 2
7732   fi
7733 done
7734 done
7735
7736 fi
7737 fi
7738 WINDMC=$ac_cv_prog_WINDMC
7739 if test -n "$WINDMC"; then
7740   echo "$as_me:$LINENO: result: $WINDMC" >&5
7741 echo "${ECHO_T}$WINDMC" >&6
7742 else
7743   echo "$as_me:$LINENO: result: no" >&5
7744 echo "${ECHO_T}no" >&6
7745 fi
7746
7747   done
7748 fi
7749
7750 for ncn_progname in windmc; do
7751   if test -n "$ncn_tool_prefix"; then
7752     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7753 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7754 echo "$as_me:$LINENO: checking for $ac_word" >&5
7755 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7756 if test "${ac_cv_prog_WINDMC+set}" = set; then
7757   echo $ECHO_N "(cached) $ECHO_C" >&6
7758 else
7759   if test -n "$WINDMC"; then
7760   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7761 else
7762 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7763 for as_dir in $PATH
7764 do
7765   IFS=$as_save_IFS
7766   test -z "$as_dir" && as_dir=.
7767   for ac_exec_ext in '' $ac_executable_extensions; do
7768   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7769     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7770     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7771     break 2
7772   fi
7773 done
7774 done
7775
7776 fi
7777 fi
7778 WINDMC=$ac_cv_prog_WINDMC
7779 if test -n "$WINDMC"; then
7780   echo "$as_me:$LINENO: result: $WINDMC" >&5
7781 echo "${ECHO_T}$WINDMC" >&6
7782 else
7783   echo "$as_me:$LINENO: result: no" >&5
7784 echo "${ECHO_T}no" >&6
7785 fi
7786
7787   fi
7788   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7789     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7790 set dummy ${ncn_progname}; ac_word=$2
7791 echo "$as_me:$LINENO: checking for $ac_word" >&5
7792 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7793 if test "${ac_cv_prog_WINDMC+set}" = set; then
7794   echo $ECHO_N "(cached) $ECHO_C" >&6
7795 else
7796   if test -n "$WINDMC"; then
7797   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7798 else
7799 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7800 for as_dir in $PATH
7801 do
7802   IFS=$as_save_IFS
7803   test -z "$as_dir" && as_dir=.
7804   for ac_exec_ext in '' $ac_executable_extensions; do
7805   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7806     ac_cv_prog_WINDMC="${ncn_progname}"
7807     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7808     break 2
7809   fi
7810 done
7811 done
7812
7813 fi
7814 fi
7815 WINDMC=$ac_cv_prog_WINDMC
7816 if test -n "$WINDMC"; then
7817   echo "$as_me:$LINENO: result: $WINDMC" >&5
7818 echo "${ECHO_T}$WINDMC" >&6
7819 else
7820   echo "$as_me:$LINENO: result: no" >&5
7821 echo "${ECHO_T}no" >&6
7822 fi
7823
7824   fi
7825   test -n "$ac_cv_prog_WINDMC" && break
7826 done
7827
7828 if test -z "$ac_cv_prog_WINDMC" ; then
7829   set dummy windmc
7830   if test $build = $host ; then
7831     WINDMC="$2"
7832   else
7833     WINDMC="${ncn_tool_prefix}$2"
7834   fi
7835 fi
7836
7837
7838
7839 if test -n "$OBJCOPY"; then
7840   ac_cv_prog_OBJCOPY=$OBJCOPY
7841 elif test -n "$ac_cv_prog_OBJCOPY"; then
7842   OBJCOPY=$ac_cv_prog_OBJCOPY
7843 fi
7844
7845 if test -n "$ac_cv_prog_OBJCOPY"; then
7846   for ncn_progname in objcopy; do
7847     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7848 set dummy ${ncn_progname}; ac_word=$2
7849 echo "$as_me:$LINENO: checking for $ac_word" >&5
7850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7851 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7852   echo $ECHO_N "(cached) $ECHO_C" >&6
7853 else
7854   if test -n "$OBJCOPY"; then
7855   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7856 else
7857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7858 for as_dir in $PATH
7859 do
7860   IFS=$as_save_IFS
7861   test -z "$as_dir" && as_dir=.
7862   for ac_exec_ext in '' $ac_executable_extensions; do
7863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7864     ac_cv_prog_OBJCOPY="${ncn_progname}"
7865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7866     break 2
7867   fi
7868 done
7869 done
7870
7871 fi
7872 fi
7873 OBJCOPY=$ac_cv_prog_OBJCOPY
7874 if test -n "$OBJCOPY"; then
7875   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7876 echo "${ECHO_T}$OBJCOPY" >&6
7877 else
7878   echo "$as_me:$LINENO: result: no" >&5
7879 echo "${ECHO_T}no" >&6
7880 fi
7881
7882   done
7883 fi
7884
7885 for ncn_progname in objcopy; do
7886   if test -n "$ncn_tool_prefix"; then
7887     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7888 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7889 echo "$as_me:$LINENO: checking for $ac_word" >&5
7890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7891 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7892   echo $ECHO_N "(cached) $ECHO_C" >&6
7893 else
7894   if test -n "$OBJCOPY"; then
7895   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7896 else
7897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7898 for as_dir in $PATH
7899 do
7900   IFS=$as_save_IFS
7901   test -z "$as_dir" && as_dir=.
7902   for ac_exec_ext in '' $ac_executable_extensions; do
7903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7904     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7906     break 2
7907   fi
7908 done
7909 done
7910
7911 fi
7912 fi
7913 OBJCOPY=$ac_cv_prog_OBJCOPY
7914 if test -n "$OBJCOPY"; then
7915   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7916 echo "${ECHO_T}$OBJCOPY" >&6
7917 else
7918   echo "$as_me:$LINENO: result: no" >&5
7919 echo "${ECHO_T}no" >&6
7920 fi
7921
7922   fi
7923   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7924     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7925 set dummy ${ncn_progname}; ac_word=$2
7926 echo "$as_me:$LINENO: checking for $ac_word" >&5
7927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7928 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7929   echo $ECHO_N "(cached) $ECHO_C" >&6
7930 else
7931   if test -n "$OBJCOPY"; then
7932   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7933 else
7934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7935 for as_dir in $PATH
7936 do
7937   IFS=$as_save_IFS
7938   test -z "$as_dir" && as_dir=.
7939   for ac_exec_ext in '' $ac_executable_extensions; do
7940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7941     ac_cv_prog_OBJCOPY="${ncn_progname}"
7942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7943     break 2
7944   fi
7945 done
7946 done
7947
7948 fi
7949 fi
7950 OBJCOPY=$ac_cv_prog_OBJCOPY
7951 if test -n "$OBJCOPY"; then
7952   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7953 echo "${ECHO_T}$OBJCOPY" >&6
7954 else
7955   echo "$as_me:$LINENO: result: no" >&5
7956 echo "${ECHO_T}no" >&6
7957 fi
7958
7959   fi
7960   test -n "$ac_cv_prog_OBJCOPY" && break
7961 done
7962
7963 if test -z "$ac_cv_prog_OBJCOPY" ; then
7964   set dummy objcopy
7965   if test $build = $host ; then
7966     OBJCOPY="$2"
7967   else
7968     OBJCOPY="${ncn_tool_prefix}$2"
7969   fi
7970 fi
7971
7972
7973
7974 if test -n "$OBJDUMP"; then
7975   ac_cv_prog_OBJDUMP=$OBJDUMP
7976 elif test -n "$ac_cv_prog_OBJDUMP"; then
7977   OBJDUMP=$ac_cv_prog_OBJDUMP
7978 fi
7979
7980 if test -n "$ac_cv_prog_OBJDUMP"; then
7981   for ncn_progname in objdump; do
7982     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7983 set dummy ${ncn_progname}; ac_word=$2
7984 echo "$as_me:$LINENO: checking for $ac_word" >&5
7985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7986 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7987   echo $ECHO_N "(cached) $ECHO_C" >&6
7988 else
7989   if test -n "$OBJDUMP"; then
7990   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7991 else
7992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7993 for as_dir in $PATH
7994 do
7995   IFS=$as_save_IFS
7996   test -z "$as_dir" && as_dir=.
7997   for ac_exec_ext in '' $ac_executable_extensions; do
7998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7999     ac_cv_prog_OBJDUMP="${ncn_progname}"
8000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8001     break 2
8002   fi
8003 done
8004 done
8005
8006 fi
8007 fi
8008 OBJDUMP=$ac_cv_prog_OBJDUMP
8009 if test -n "$OBJDUMP"; then
8010   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8011 echo "${ECHO_T}$OBJDUMP" >&6
8012 else
8013   echo "$as_me:$LINENO: result: no" >&5
8014 echo "${ECHO_T}no" >&6
8015 fi
8016
8017   done
8018 fi
8019
8020 for ncn_progname in objdump; do
8021   if test -n "$ncn_tool_prefix"; then
8022     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8023 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8024 echo "$as_me:$LINENO: checking for $ac_word" >&5
8025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8026 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8027   echo $ECHO_N "(cached) $ECHO_C" >&6
8028 else
8029   if test -n "$OBJDUMP"; then
8030   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8031 else
8032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8033 for as_dir in $PATH
8034 do
8035   IFS=$as_save_IFS
8036   test -z "$as_dir" && as_dir=.
8037   for ac_exec_ext in '' $ac_executable_extensions; do
8038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8039     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8041     break 2
8042   fi
8043 done
8044 done
8045
8046 fi
8047 fi
8048 OBJDUMP=$ac_cv_prog_OBJDUMP
8049 if test -n "$OBJDUMP"; then
8050   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8051 echo "${ECHO_T}$OBJDUMP" >&6
8052 else
8053   echo "$as_me:$LINENO: result: no" >&5
8054 echo "${ECHO_T}no" >&6
8055 fi
8056
8057   fi
8058   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8059     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8060 set dummy ${ncn_progname}; ac_word=$2
8061 echo "$as_me:$LINENO: checking for $ac_word" >&5
8062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8063 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8064   echo $ECHO_N "(cached) $ECHO_C" >&6
8065 else
8066   if test -n "$OBJDUMP"; then
8067   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8068 else
8069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8070 for as_dir in $PATH
8071 do
8072   IFS=$as_save_IFS
8073   test -z "$as_dir" && as_dir=.
8074   for ac_exec_ext in '' $ac_executable_extensions; do
8075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8076     ac_cv_prog_OBJDUMP="${ncn_progname}"
8077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8078     break 2
8079   fi
8080 done
8081 done
8082
8083 fi
8084 fi
8085 OBJDUMP=$ac_cv_prog_OBJDUMP
8086 if test -n "$OBJDUMP"; then
8087   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8088 echo "${ECHO_T}$OBJDUMP" >&6
8089 else
8090   echo "$as_me:$LINENO: result: no" >&5
8091 echo "${ECHO_T}no" >&6
8092 fi
8093
8094   fi
8095   test -n "$ac_cv_prog_OBJDUMP" && break
8096 done
8097
8098 if test -z "$ac_cv_prog_OBJDUMP" ; then
8099   set dummy objdump
8100   if test $build = $host ; then
8101     OBJDUMP="$2"
8102   else
8103     OBJDUMP="${ncn_tool_prefix}$2"
8104   fi
8105 fi
8106
8107
8108
8109
8110
8111
8112 # Target tools.
8113
8114 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8115 if test "${with_build_time_tools+set}" = set; then
8116   withval="$with_build_time_tools"
8117   case x"$withval" in
8118      x/*) ;;
8119      *)
8120        with_build_time_tools=
8121        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8122 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8123        ;;
8124    esac
8125 else
8126   with_build_time_tools=
8127 fi;
8128
8129
8130
8131 if test -n "$CC_FOR_TARGET"; then
8132   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8133 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8134   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8135 fi
8136
8137 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8138   for ncn_progname in cc gcc; do
8139     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8140 set dummy ${ncn_progname}; ac_word=$2
8141 echo "$as_me:$LINENO: checking for $ac_word" >&5
8142 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8143 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8144   echo $ECHO_N "(cached) $ECHO_C" >&6
8145 else
8146   if test -n "$CC_FOR_TARGET"; then
8147   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8148 else
8149 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8150 for as_dir in $PATH
8151 do
8152   IFS=$as_save_IFS
8153   test -z "$as_dir" && as_dir=.
8154   for ac_exec_ext in '' $ac_executable_extensions; do
8155   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8156     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8157     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8158     break 2
8159   fi
8160 done
8161 done
8162
8163 fi
8164 fi
8165 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8166 if test -n "$CC_FOR_TARGET"; then
8167   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8168 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8169 else
8170   echo "$as_me:$LINENO: result: no" >&5
8171 echo "${ECHO_T}no" >&6
8172 fi
8173
8174   done
8175 fi
8176
8177 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8178   for ncn_progname in cc gcc; do
8179     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8180 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8181     if test -x $with_build_time_tools/${ncn_progname}; then
8182       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8183       echo "$as_me:$LINENO: result: yes" >&5
8184 echo "${ECHO_T}yes" >&6
8185       break
8186     else
8187       echo "$as_me:$LINENO: result: no" >&5
8188 echo "${ECHO_T}no" >&6
8189     fi
8190   done
8191 fi
8192
8193 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8194   for ncn_progname in cc gcc; do
8195     if test -n "$ncn_target_tool_prefix"; then
8196       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8197 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8198 echo "$as_me:$LINENO: checking for $ac_word" >&5
8199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8200 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8201   echo $ECHO_N "(cached) $ECHO_C" >&6
8202 else
8203   if test -n "$CC_FOR_TARGET"; then
8204   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8205 else
8206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8207 for as_dir in $PATH
8208 do
8209   IFS=$as_save_IFS
8210   test -z "$as_dir" && as_dir=.
8211   for ac_exec_ext in '' $ac_executable_extensions; do
8212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8213     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8215     break 2
8216   fi
8217 done
8218 done
8219
8220 fi
8221 fi
8222 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8223 if test -n "$CC_FOR_TARGET"; then
8224   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8225 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8226 else
8227   echo "$as_me:$LINENO: result: no" >&5
8228 echo "${ECHO_T}no" >&6
8229 fi
8230
8231     fi
8232     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8233       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8234 set dummy ${ncn_progname}; ac_word=$2
8235 echo "$as_me:$LINENO: checking for $ac_word" >&5
8236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8237 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8238   echo $ECHO_N "(cached) $ECHO_C" >&6
8239 else
8240   if test -n "$CC_FOR_TARGET"; then
8241   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8242 else
8243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8244 for as_dir in $PATH
8245 do
8246   IFS=$as_save_IFS
8247   test -z "$as_dir" && as_dir=.
8248   for ac_exec_ext in '' $ac_executable_extensions; do
8249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8250     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8252     break 2
8253   fi
8254 done
8255 done
8256
8257 fi
8258 fi
8259 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8260 if test -n "$CC_FOR_TARGET"; then
8261   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8262 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8263 else
8264   echo "$as_me:$LINENO: result: no" >&5
8265 echo "${ECHO_T}no" >&6
8266 fi
8267
8268     fi
8269     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8270   done
8271 fi
8272
8273 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8274   set dummy cc gcc
8275   if test $build = $target ; then
8276     CC_FOR_TARGET="$2"
8277   else
8278     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8279   fi
8280 else
8281   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8282 fi
8283
8284
8285
8286 if test -n "$CXX_FOR_TARGET"; then
8287   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8288 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8289   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8290 fi
8291
8292 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8293   for ncn_progname in c++ g++ cxx gxx; do
8294     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8295 set dummy ${ncn_progname}; ac_word=$2
8296 echo "$as_me:$LINENO: checking for $ac_word" >&5
8297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8298 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8299   echo $ECHO_N "(cached) $ECHO_C" >&6
8300 else
8301   if test -n "$CXX_FOR_TARGET"; then
8302   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8303 else
8304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8305 for as_dir in $PATH
8306 do
8307   IFS=$as_save_IFS
8308   test -z "$as_dir" && as_dir=.
8309   for ac_exec_ext in '' $ac_executable_extensions; do
8310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8311     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8313     break 2
8314   fi
8315 done
8316 done
8317
8318 fi
8319 fi
8320 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8321 if test -n "$CXX_FOR_TARGET"; then
8322   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8323 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8324 else
8325   echo "$as_me:$LINENO: result: no" >&5
8326 echo "${ECHO_T}no" >&6
8327 fi
8328
8329   done
8330 fi
8331
8332 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8333   for ncn_progname in c++ g++ cxx gxx; do
8334     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8335 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8336     if test -x $with_build_time_tools/${ncn_progname}; then
8337       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8338       echo "$as_me:$LINENO: result: yes" >&5
8339 echo "${ECHO_T}yes" >&6
8340       break
8341     else
8342       echo "$as_me:$LINENO: result: no" >&5
8343 echo "${ECHO_T}no" >&6
8344     fi
8345   done
8346 fi
8347
8348 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8349   for ncn_progname in c++ g++ cxx gxx; do
8350     if test -n "$ncn_target_tool_prefix"; then
8351       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8352 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8353 echo "$as_me:$LINENO: checking for $ac_word" >&5
8354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8355 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8356   echo $ECHO_N "(cached) $ECHO_C" >&6
8357 else
8358   if test -n "$CXX_FOR_TARGET"; then
8359   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8360 else
8361 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8362 for as_dir in $PATH
8363 do
8364   IFS=$as_save_IFS
8365   test -z "$as_dir" && as_dir=.
8366   for ac_exec_ext in '' $ac_executable_extensions; do
8367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8368     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8370     break 2
8371   fi
8372 done
8373 done
8374
8375 fi
8376 fi
8377 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8378 if test -n "$CXX_FOR_TARGET"; then
8379   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8380 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8381 else
8382   echo "$as_me:$LINENO: result: no" >&5
8383 echo "${ECHO_T}no" >&6
8384 fi
8385
8386     fi
8387     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8388       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8389 set dummy ${ncn_progname}; ac_word=$2
8390 echo "$as_me:$LINENO: checking for $ac_word" >&5
8391 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8392 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8393   echo $ECHO_N "(cached) $ECHO_C" >&6
8394 else
8395   if test -n "$CXX_FOR_TARGET"; then
8396   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8397 else
8398 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8399 for as_dir in $PATH
8400 do
8401   IFS=$as_save_IFS
8402   test -z "$as_dir" && as_dir=.
8403   for ac_exec_ext in '' $ac_executable_extensions; do
8404   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8405     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8406     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8407     break 2
8408   fi
8409 done
8410 done
8411
8412 fi
8413 fi
8414 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8415 if test -n "$CXX_FOR_TARGET"; then
8416   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8417 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8418 else
8419   echo "$as_me:$LINENO: result: no" >&5
8420 echo "${ECHO_T}no" >&6
8421 fi
8422
8423     fi
8424     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8425   done
8426 fi
8427
8428 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8429   set dummy c++ g++ cxx gxx
8430   if test $build = $target ; then
8431     CXX_FOR_TARGET="$2"
8432   else
8433     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8434   fi
8435 else
8436   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8437 fi
8438
8439
8440
8441 if test -n "$GCC_FOR_TARGET"; then
8442   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8443 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8444   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8445 fi
8446
8447 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8448   for ncn_progname in gcc; do
8449     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8450 set dummy ${ncn_progname}; ac_word=$2
8451 echo "$as_me:$LINENO: checking for $ac_word" >&5
8452 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8453 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8454   echo $ECHO_N "(cached) $ECHO_C" >&6
8455 else
8456   if test -n "$GCC_FOR_TARGET"; then
8457   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8458 else
8459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8460 for as_dir in $PATH
8461 do
8462   IFS=$as_save_IFS
8463   test -z "$as_dir" && as_dir=.
8464   for ac_exec_ext in '' $ac_executable_extensions; do
8465   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8466     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8467     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8468     break 2
8469   fi
8470 done
8471 done
8472
8473 fi
8474 fi
8475 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8476 if test -n "$GCC_FOR_TARGET"; then
8477   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8478 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8479 else
8480   echo "$as_me:$LINENO: result: no" >&5
8481 echo "${ECHO_T}no" >&6
8482 fi
8483
8484   done
8485 fi
8486
8487 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8488   for ncn_progname in gcc; do
8489     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8490 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8491     if test -x $with_build_time_tools/${ncn_progname}; then
8492       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8493       echo "$as_me:$LINENO: result: yes" >&5
8494 echo "${ECHO_T}yes" >&6
8495       break
8496     else
8497       echo "$as_me:$LINENO: result: no" >&5
8498 echo "${ECHO_T}no" >&6
8499     fi
8500   done
8501 fi
8502
8503 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8504   for ncn_progname in gcc; do
8505     if test -n "$ncn_target_tool_prefix"; then
8506       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8507 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8508 echo "$as_me:$LINENO: checking for $ac_word" >&5
8509 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8510 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8511   echo $ECHO_N "(cached) $ECHO_C" >&6
8512 else
8513   if test -n "$GCC_FOR_TARGET"; then
8514   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8515 else
8516 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8517 for as_dir in $PATH
8518 do
8519   IFS=$as_save_IFS
8520   test -z "$as_dir" && as_dir=.
8521   for ac_exec_ext in '' $ac_executable_extensions; do
8522   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8523     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8524     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8525     break 2
8526   fi
8527 done
8528 done
8529
8530 fi
8531 fi
8532 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8533 if test -n "$GCC_FOR_TARGET"; then
8534   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8535 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8536 else
8537   echo "$as_me:$LINENO: result: no" >&5
8538 echo "${ECHO_T}no" >&6
8539 fi
8540
8541     fi
8542     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8543       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8544 set dummy ${ncn_progname}; ac_word=$2
8545 echo "$as_me:$LINENO: checking for $ac_word" >&5
8546 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8547 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8548   echo $ECHO_N "(cached) $ECHO_C" >&6
8549 else
8550   if test -n "$GCC_FOR_TARGET"; then
8551   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8552 else
8553 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8554 for as_dir in $PATH
8555 do
8556   IFS=$as_save_IFS
8557   test -z "$as_dir" && as_dir=.
8558   for ac_exec_ext in '' $ac_executable_extensions; do
8559   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8560     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8561     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8562     break 2
8563   fi
8564 done
8565 done
8566
8567 fi
8568 fi
8569 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8570 if test -n "$GCC_FOR_TARGET"; then
8571   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8572 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8573 else
8574   echo "$as_me:$LINENO: result: no" >&5
8575 echo "${ECHO_T}no" >&6
8576 fi
8577
8578     fi
8579     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8580   done
8581 fi
8582
8583 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8584   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8585 else
8586   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8587 fi
8588
8589
8590
8591 if test -n "$GCJ_FOR_TARGET"; then
8592   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8593 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8594   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8595 fi
8596
8597 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8598   for ncn_progname in gcj; do
8599     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8600 set dummy ${ncn_progname}; ac_word=$2
8601 echo "$as_me:$LINENO: checking for $ac_word" >&5
8602 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8603 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8604   echo $ECHO_N "(cached) $ECHO_C" >&6
8605 else
8606   if test -n "$GCJ_FOR_TARGET"; then
8607   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8608 else
8609 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8610 for as_dir in $PATH
8611 do
8612   IFS=$as_save_IFS
8613   test -z "$as_dir" && as_dir=.
8614   for ac_exec_ext in '' $ac_executable_extensions; do
8615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8616     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8618     break 2
8619   fi
8620 done
8621 done
8622
8623 fi
8624 fi
8625 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8626 if test -n "$GCJ_FOR_TARGET"; then
8627   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8628 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8629 else
8630   echo "$as_me:$LINENO: result: no" >&5
8631 echo "${ECHO_T}no" >&6
8632 fi
8633
8634   done
8635 fi
8636
8637 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8638   for ncn_progname in gcj; do
8639     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8640 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8641     if test -x $with_build_time_tools/${ncn_progname}; then
8642       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8643       echo "$as_me:$LINENO: result: yes" >&5
8644 echo "${ECHO_T}yes" >&6
8645       break
8646     else
8647       echo "$as_me:$LINENO: result: no" >&5
8648 echo "${ECHO_T}no" >&6
8649     fi
8650   done
8651 fi
8652
8653 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8654   for ncn_progname in gcj; do
8655     if test -n "$ncn_target_tool_prefix"; then
8656       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8657 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8658 echo "$as_me:$LINENO: checking for $ac_word" >&5
8659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8660 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8661   echo $ECHO_N "(cached) $ECHO_C" >&6
8662 else
8663   if test -n "$GCJ_FOR_TARGET"; then
8664   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8665 else
8666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8667 for as_dir in $PATH
8668 do
8669   IFS=$as_save_IFS
8670   test -z "$as_dir" && as_dir=.
8671   for ac_exec_ext in '' $ac_executable_extensions; do
8672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8673     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8675     break 2
8676   fi
8677 done
8678 done
8679
8680 fi
8681 fi
8682 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8683 if test -n "$GCJ_FOR_TARGET"; then
8684   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8685 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8686 else
8687   echo "$as_me:$LINENO: result: no" >&5
8688 echo "${ECHO_T}no" >&6
8689 fi
8690
8691     fi
8692     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8693       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8694 set dummy ${ncn_progname}; ac_word=$2
8695 echo "$as_me:$LINENO: checking for $ac_word" >&5
8696 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8697 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8698   echo $ECHO_N "(cached) $ECHO_C" >&6
8699 else
8700   if test -n "$GCJ_FOR_TARGET"; then
8701   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8702 else
8703 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8704 for as_dir in $PATH
8705 do
8706   IFS=$as_save_IFS
8707   test -z "$as_dir" && as_dir=.
8708   for ac_exec_ext in '' $ac_executable_extensions; do
8709   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8710     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8711     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8712     break 2
8713   fi
8714 done
8715 done
8716
8717 fi
8718 fi
8719 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8720 if test -n "$GCJ_FOR_TARGET"; then
8721   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8722 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8723 else
8724   echo "$as_me:$LINENO: result: no" >&5
8725 echo "${ECHO_T}no" >&6
8726 fi
8727
8728     fi
8729     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8730   done
8731 fi
8732
8733 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8734   set dummy gcj
8735   if test $build = $target ; then
8736     GCJ_FOR_TARGET="$2"
8737   else
8738     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8739   fi
8740 else
8741   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8742 fi
8743
8744
8745
8746 if test -n "$GFORTRAN_FOR_TARGET"; then
8747   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8748 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8749   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8750 fi
8751
8752 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8753   for ncn_progname in gfortran; do
8754     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8755 set dummy ${ncn_progname}; ac_word=$2
8756 echo "$as_me:$LINENO: checking for $ac_word" >&5
8757 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8758 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8759   echo $ECHO_N "(cached) $ECHO_C" >&6
8760 else
8761   if test -n "$GFORTRAN_FOR_TARGET"; then
8762   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8763 else
8764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8765 for as_dir in $PATH
8766 do
8767   IFS=$as_save_IFS
8768   test -z "$as_dir" && as_dir=.
8769   for ac_exec_ext in '' $ac_executable_extensions; do
8770   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8771     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8772     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8773     break 2
8774   fi
8775 done
8776 done
8777
8778 fi
8779 fi
8780 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8781 if test -n "$GFORTRAN_FOR_TARGET"; then
8782   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8783 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8784 else
8785   echo "$as_me:$LINENO: result: no" >&5
8786 echo "${ECHO_T}no" >&6
8787 fi
8788
8789   done
8790 fi
8791
8792 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8793   for ncn_progname in gfortran; do
8794     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8795 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8796     if test -x $with_build_time_tools/${ncn_progname}; then
8797       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8798       echo "$as_me:$LINENO: result: yes" >&5
8799 echo "${ECHO_T}yes" >&6
8800       break
8801     else
8802       echo "$as_me:$LINENO: result: no" >&5
8803 echo "${ECHO_T}no" >&6
8804     fi
8805   done
8806 fi
8807
8808 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8809   for ncn_progname in gfortran; do
8810     if test -n "$ncn_target_tool_prefix"; then
8811       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8812 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8813 echo "$as_me:$LINENO: checking for $ac_word" >&5
8814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8815 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8816   echo $ECHO_N "(cached) $ECHO_C" >&6
8817 else
8818   if test -n "$GFORTRAN_FOR_TARGET"; then
8819   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8820 else
8821 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8822 for as_dir in $PATH
8823 do
8824   IFS=$as_save_IFS
8825   test -z "$as_dir" && as_dir=.
8826   for ac_exec_ext in '' $ac_executable_extensions; do
8827   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8828     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8829     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8830     break 2
8831   fi
8832 done
8833 done
8834
8835 fi
8836 fi
8837 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8838 if test -n "$GFORTRAN_FOR_TARGET"; then
8839   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8840 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8841 else
8842   echo "$as_me:$LINENO: result: no" >&5
8843 echo "${ECHO_T}no" >&6
8844 fi
8845
8846     fi
8847     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8848       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8849 set dummy ${ncn_progname}; ac_word=$2
8850 echo "$as_me:$LINENO: checking for $ac_word" >&5
8851 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8852 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8853   echo $ECHO_N "(cached) $ECHO_C" >&6
8854 else
8855   if test -n "$GFORTRAN_FOR_TARGET"; then
8856   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8857 else
8858 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8859 for as_dir in $PATH
8860 do
8861   IFS=$as_save_IFS
8862   test -z "$as_dir" && as_dir=.
8863   for ac_exec_ext in '' $ac_executable_extensions; do
8864   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8865     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8866     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8867     break 2
8868   fi
8869 done
8870 done
8871
8872 fi
8873 fi
8874 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8875 if test -n "$GFORTRAN_FOR_TARGET"; then
8876   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8877 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8878 else
8879   echo "$as_me:$LINENO: result: no" >&5
8880 echo "${ECHO_T}no" >&6
8881 fi
8882
8883     fi
8884     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8885   done
8886 fi
8887
8888 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8889   set dummy gfortran
8890   if test $build = $target ; then
8891     GFORTRAN_FOR_TARGET="$2"
8892   else
8893     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8894   fi
8895 else
8896   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8897 fi
8898
8899
8900
8901 cat > conftest.c << \EOF
8902 #ifdef __GNUC__
8903   gcc_yay;
8904 #endif
8905 EOF
8906 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8907   have_gcc_for_target=yes
8908 else
8909   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8910   have_gcc_for_target=no
8911 fi
8912 rm conftest.c
8913
8914
8915
8916
8917 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8918   if test -n "$with_build_time_tools"; then
8919     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8920 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8921     if test -x $with_build_time_tools/ar; then
8922       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8923       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8924       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8925 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8926     else
8927       echo "$as_me:$LINENO: result: no" >&5
8928 echo "${ECHO_T}no" >&6
8929     fi
8930   elif test $build != $host && test $have_gcc_for_target = yes; then
8931     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8932     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8933     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8934   fi
8935 fi
8936 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8937   # Extract the first word of "ar", so it can be a program name with args.
8938 set dummy ar; ac_word=$2
8939 echo "$as_me:$LINENO: checking for $ac_word" >&5
8940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8941 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8942   echo $ECHO_N "(cached) $ECHO_C" >&6
8943 else
8944   case $AR_FOR_TARGET in
8945   [\\/]* | ?:[\\/]*)
8946   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8947   ;;
8948   *)
8949   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8950 for as_dir in $gcc_cv_tool_dirs
8951 do
8952   IFS=$as_save_IFS
8953   test -z "$as_dir" && as_dir=.
8954   for ac_exec_ext in '' $ac_executable_extensions; do
8955   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8956     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8957     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8958     break 2
8959   fi
8960 done
8961 done
8962
8963   ;;
8964 esac
8965 fi
8966 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8967
8968 if test -n "$AR_FOR_TARGET"; then
8969   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8970 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8971 else
8972   echo "$as_me:$LINENO: result: no" >&5
8973 echo "${ECHO_T}no" >&6
8974 fi
8975
8976 fi
8977 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8978
8979
8980 if test -n "$AR_FOR_TARGET"; then
8981   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8982 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8983   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8984 fi
8985
8986 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8987   for ncn_progname in ar; do
8988     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8989 set dummy ${ncn_progname}; ac_word=$2
8990 echo "$as_me:$LINENO: checking for $ac_word" >&5
8991 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8992 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8993   echo $ECHO_N "(cached) $ECHO_C" >&6
8994 else
8995   if test -n "$AR_FOR_TARGET"; then
8996   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8997 else
8998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8999 for as_dir in $PATH
9000 do
9001   IFS=$as_save_IFS
9002   test -z "$as_dir" && as_dir=.
9003   for ac_exec_ext in '' $ac_executable_extensions; do
9004   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9005     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9006     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9007     break 2
9008   fi
9009 done
9010 done
9011
9012 fi
9013 fi
9014 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9015 if test -n "$AR_FOR_TARGET"; then
9016   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9017 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9018 else
9019   echo "$as_me:$LINENO: result: no" >&5
9020 echo "${ECHO_T}no" >&6
9021 fi
9022
9023   done
9024 fi
9025
9026 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9027   for ncn_progname in ar; do
9028     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9029 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9030     if test -x $with_build_time_tools/${ncn_progname}; then
9031       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9032       echo "$as_me:$LINENO: result: yes" >&5
9033 echo "${ECHO_T}yes" >&6
9034       break
9035     else
9036       echo "$as_me:$LINENO: result: no" >&5
9037 echo "${ECHO_T}no" >&6
9038     fi
9039   done
9040 fi
9041
9042 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9043   for ncn_progname in ar; do
9044     if test -n "$ncn_target_tool_prefix"; then
9045       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9046 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9047 echo "$as_me:$LINENO: checking for $ac_word" >&5
9048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9049 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9050   echo $ECHO_N "(cached) $ECHO_C" >&6
9051 else
9052   if test -n "$AR_FOR_TARGET"; then
9053   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9054 else
9055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9056 for as_dir in $PATH
9057 do
9058   IFS=$as_save_IFS
9059   test -z "$as_dir" && as_dir=.
9060   for ac_exec_ext in '' $ac_executable_extensions; do
9061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9062     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9064     break 2
9065   fi
9066 done
9067 done
9068
9069 fi
9070 fi
9071 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9072 if test -n "$AR_FOR_TARGET"; then
9073   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9074 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9075 else
9076   echo "$as_me:$LINENO: result: no" >&5
9077 echo "${ECHO_T}no" >&6
9078 fi
9079
9080     fi
9081     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9082       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9083 set dummy ${ncn_progname}; ac_word=$2
9084 echo "$as_me:$LINENO: checking for $ac_word" >&5
9085 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9086 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9087   echo $ECHO_N "(cached) $ECHO_C" >&6
9088 else
9089   if test -n "$AR_FOR_TARGET"; then
9090   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9091 else
9092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9093 for as_dir in $PATH
9094 do
9095   IFS=$as_save_IFS
9096   test -z "$as_dir" && as_dir=.
9097   for ac_exec_ext in '' $ac_executable_extensions; do
9098   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9099     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9100     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9101     break 2
9102   fi
9103 done
9104 done
9105
9106 fi
9107 fi
9108 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9109 if test -n "$AR_FOR_TARGET"; then
9110   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9111 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9112 else
9113   echo "$as_me:$LINENO: result: no" >&5
9114 echo "${ECHO_T}no" >&6
9115 fi
9116
9117     fi
9118     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9119   done
9120 fi
9121
9122 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9123   set dummy ar
9124   if test $build = $target ; then
9125     AR_FOR_TARGET="$2"
9126   else
9127     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9128   fi
9129 else
9130   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9131 fi
9132
9133 else
9134   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9135 fi
9136
9137
9138
9139
9140 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9141   if test -n "$with_build_time_tools"; then
9142     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9143 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9144     if test -x $with_build_time_tools/as; then
9145       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9146       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9147       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9148 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9149     else
9150       echo "$as_me:$LINENO: result: no" >&5
9151 echo "${ECHO_T}no" >&6
9152     fi
9153   elif test $build != $host && test $have_gcc_for_target = yes; then
9154     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9155     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9156     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9157   fi
9158 fi
9159 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9160   # Extract the first word of "as", so it can be a program name with args.
9161 set dummy as; ac_word=$2
9162 echo "$as_me:$LINENO: checking for $ac_word" >&5
9163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9164 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9165   echo $ECHO_N "(cached) $ECHO_C" >&6
9166 else
9167   case $AS_FOR_TARGET in
9168   [\\/]* | ?:[\\/]*)
9169   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9170   ;;
9171   *)
9172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9173 for as_dir in $gcc_cv_tool_dirs
9174 do
9175   IFS=$as_save_IFS
9176   test -z "$as_dir" && as_dir=.
9177   for ac_exec_ext in '' $ac_executable_extensions; do
9178   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9179     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9180     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9181     break 2
9182   fi
9183 done
9184 done
9185
9186   ;;
9187 esac
9188 fi
9189 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9190
9191 if test -n "$AS_FOR_TARGET"; then
9192   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9193 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9194 else
9195   echo "$as_me:$LINENO: result: no" >&5
9196 echo "${ECHO_T}no" >&6
9197 fi
9198
9199 fi
9200 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9201
9202
9203 if test -n "$AS_FOR_TARGET"; then
9204   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9205 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9206   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9207 fi
9208
9209 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9210   for ncn_progname in as; do
9211     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9212 set dummy ${ncn_progname}; ac_word=$2
9213 echo "$as_me:$LINENO: checking for $ac_word" >&5
9214 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9215 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9216   echo $ECHO_N "(cached) $ECHO_C" >&6
9217 else
9218   if test -n "$AS_FOR_TARGET"; then
9219   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9220 else
9221 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9222 for as_dir in $PATH
9223 do
9224   IFS=$as_save_IFS
9225   test -z "$as_dir" && as_dir=.
9226   for ac_exec_ext in '' $ac_executable_extensions; do
9227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9228     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9230     break 2
9231   fi
9232 done
9233 done
9234
9235 fi
9236 fi
9237 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9238 if test -n "$AS_FOR_TARGET"; then
9239   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9240 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9241 else
9242   echo "$as_me:$LINENO: result: no" >&5
9243 echo "${ECHO_T}no" >&6
9244 fi
9245
9246   done
9247 fi
9248
9249 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9250   for ncn_progname in as; do
9251     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9252 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9253     if test -x $with_build_time_tools/${ncn_progname}; then
9254       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9255       echo "$as_me:$LINENO: result: yes" >&5
9256 echo "${ECHO_T}yes" >&6
9257       break
9258     else
9259       echo "$as_me:$LINENO: result: no" >&5
9260 echo "${ECHO_T}no" >&6
9261     fi
9262   done
9263 fi
9264
9265 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9266   for ncn_progname in as; do
9267     if test -n "$ncn_target_tool_prefix"; then
9268       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9269 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9270 echo "$as_me:$LINENO: checking for $ac_word" >&5
9271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9272 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9273   echo $ECHO_N "(cached) $ECHO_C" >&6
9274 else
9275   if test -n "$AS_FOR_TARGET"; then
9276   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9277 else
9278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9279 for as_dir in $PATH
9280 do
9281   IFS=$as_save_IFS
9282   test -z "$as_dir" && as_dir=.
9283   for ac_exec_ext in '' $ac_executable_extensions; do
9284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9285     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9287     break 2
9288   fi
9289 done
9290 done
9291
9292 fi
9293 fi
9294 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9295 if test -n "$AS_FOR_TARGET"; then
9296   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9297 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9298 else
9299   echo "$as_me:$LINENO: result: no" >&5
9300 echo "${ECHO_T}no" >&6
9301 fi
9302
9303     fi
9304     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9305       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9306 set dummy ${ncn_progname}; ac_word=$2
9307 echo "$as_me:$LINENO: checking for $ac_word" >&5
9308 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9309 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9310   echo $ECHO_N "(cached) $ECHO_C" >&6
9311 else
9312   if test -n "$AS_FOR_TARGET"; then
9313   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9314 else
9315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9316 for as_dir in $PATH
9317 do
9318   IFS=$as_save_IFS
9319   test -z "$as_dir" && as_dir=.
9320   for ac_exec_ext in '' $ac_executable_extensions; do
9321   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9322     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9323     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9324     break 2
9325   fi
9326 done
9327 done
9328
9329 fi
9330 fi
9331 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9332 if test -n "$AS_FOR_TARGET"; then
9333   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9334 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9335 else
9336   echo "$as_me:$LINENO: result: no" >&5
9337 echo "${ECHO_T}no" >&6
9338 fi
9339
9340     fi
9341     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9342   done
9343 fi
9344
9345 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9346   set dummy as
9347   if test $build = $target ; then
9348     AS_FOR_TARGET="$2"
9349   else
9350     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9351   fi
9352 else
9353   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9354 fi
9355
9356 else
9357   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9358 fi
9359
9360
9361
9362
9363 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9364   if test -n "$with_build_time_tools"; then
9365     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9366 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9367     if test -x $with_build_time_tools/dlltool; then
9368       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9369       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9370       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9371 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9372     else
9373       echo "$as_me:$LINENO: result: no" >&5
9374 echo "${ECHO_T}no" >&6
9375     fi
9376   elif test $build != $host && test $have_gcc_for_target = yes; then
9377     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9378     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9379     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9380   fi
9381 fi
9382 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9383   # Extract the first word of "dlltool", so it can be a program name with args.
9384 set dummy dlltool; ac_word=$2
9385 echo "$as_me:$LINENO: checking for $ac_word" >&5
9386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9387 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9388   echo $ECHO_N "(cached) $ECHO_C" >&6
9389 else
9390   case $DLLTOOL_FOR_TARGET in
9391   [\\/]* | ?:[\\/]*)
9392   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9393   ;;
9394   *)
9395   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9396 for as_dir in $gcc_cv_tool_dirs
9397 do
9398   IFS=$as_save_IFS
9399   test -z "$as_dir" && as_dir=.
9400   for ac_exec_ext in '' $ac_executable_extensions; do
9401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9402     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9404     break 2
9405   fi
9406 done
9407 done
9408
9409   ;;
9410 esac
9411 fi
9412 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9413
9414 if test -n "$DLLTOOL_FOR_TARGET"; then
9415   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9416 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9417 else
9418   echo "$as_me:$LINENO: result: no" >&5
9419 echo "${ECHO_T}no" >&6
9420 fi
9421
9422 fi
9423 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9424
9425
9426 if test -n "$DLLTOOL_FOR_TARGET"; then
9427   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9428 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9429   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9430 fi
9431
9432 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9433   for ncn_progname in dlltool; do
9434     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9435 set dummy ${ncn_progname}; ac_word=$2
9436 echo "$as_me:$LINENO: checking for $ac_word" >&5
9437 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9438 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9439   echo $ECHO_N "(cached) $ECHO_C" >&6
9440 else
9441   if test -n "$DLLTOOL_FOR_TARGET"; then
9442   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9443 else
9444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9445 for as_dir in $PATH
9446 do
9447   IFS=$as_save_IFS
9448   test -z "$as_dir" && as_dir=.
9449   for ac_exec_ext in '' $ac_executable_extensions; do
9450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9451     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9453     break 2
9454   fi
9455 done
9456 done
9457
9458 fi
9459 fi
9460 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9461 if test -n "$DLLTOOL_FOR_TARGET"; then
9462   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9463 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9464 else
9465   echo "$as_me:$LINENO: result: no" >&5
9466 echo "${ECHO_T}no" >&6
9467 fi
9468
9469   done
9470 fi
9471
9472 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9473   for ncn_progname in dlltool; do
9474     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9475 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9476     if test -x $with_build_time_tools/${ncn_progname}; then
9477       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9478       echo "$as_me:$LINENO: result: yes" >&5
9479 echo "${ECHO_T}yes" >&6
9480       break
9481     else
9482       echo "$as_me:$LINENO: result: no" >&5
9483 echo "${ECHO_T}no" >&6
9484     fi
9485   done
9486 fi
9487
9488 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9489   for ncn_progname in dlltool; do
9490     if test -n "$ncn_target_tool_prefix"; then
9491       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9492 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9493 echo "$as_me:$LINENO: checking for $ac_word" >&5
9494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9495 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9496   echo $ECHO_N "(cached) $ECHO_C" >&6
9497 else
9498   if test -n "$DLLTOOL_FOR_TARGET"; then
9499   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9500 else
9501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9502 for as_dir in $PATH
9503 do
9504   IFS=$as_save_IFS
9505   test -z "$as_dir" && as_dir=.
9506   for ac_exec_ext in '' $ac_executable_extensions; do
9507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9508     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9510     break 2
9511   fi
9512 done
9513 done
9514
9515 fi
9516 fi
9517 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9518 if test -n "$DLLTOOL_FOR_TARGET"; then
9519   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9520 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9521 else
9522   echo "$as_me:$LINENO: result: no" >&5
9523 echo "${ECHO_T}no" >&6
9524 fi
9525
9526     fi
9527     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9528       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9529 set dummy ${ncn_progname}; ac_word=$2
9530 echo "$as_me:$LINENO: checking for $ac_word" >&5
9531 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9532 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9533   echo $ECHO_N "(cached) $ECHO_C" >&6
9534 else
9535   if test -n "$DLLTOOL_FOR_TARGET"; then
9536   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9537 else
9538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9539 for as_dir in $PATH
9540 do
9541   IFS=$as_save_IFS
9542   test -z "$as_dir" && as_dir=.
9543   for ac_exec_ext in '' $ac_executable_extensions; do
9544   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9545     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9546     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9547     break 2
9548   fi
9549 done
9550 done
9551
9552 fi
9553 fi
9554 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9555 if test -n "$DLLTOOL_FOR_TARGET"; then
9556   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9557 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9558 else
9559   echo "$as_me:$LINENO: result: no" >&5
9560 echo "${ECHO_T}no" >&6
9561 fi
9562
9563     fi
9564     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9565   done
9566 fi
9567
9568 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9569   set dummy dlltool
9570   if test $build = $target ; then
9571     DLLTOOL_FOR_TARGET="$2"
9572   else
9573     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9574   fi
9575 else
9576   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9577 fi
9578
9579 else
9580   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9581 fi
9582
9583
9584
9585
9586 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9587   if test -n "$with_build_time_tools"; then
9588     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9589 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9590     if test -x $with_build_time_tools/ld; then
9591       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9592       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9593       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9594 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9595     else
9596       echo "$as_me:$LINENO: result: no" >&5
9597 echo "${ECHO_T}no" >&6
9598     fi
9599   elif test $build != $host && test $have_gcc_for_target = yes; then
9600     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9601     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9602     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9603   fi
9604 fi
9605 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9606   # Extract the first word of "ld", so it can be a program name with args.
9607 set dummy ld; ac_word=$2
9608 echo "$as_me:$LINENO: checking for $ac_word" >&5
9609 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9610 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9611   echo $ECHO_N "(cached) $ECHO_C" >&6
9612 else
9613   case $LD_FOR_TARGET in
9614   [\\/]* | ?:[\\/]*)
9615   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9616   ;;
9617   *)
9618   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9619 for as_dir in $gcc_cv_tool_dirs
9620 do
9621   IFS=$as_save_IFS
9622   test -z "$as_dir" && as_dir=.
9623   for ac_exec_ext in '' $ac_executable_extensions; do
9624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9625     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9627     break 2
9628   fi
9629 done
9630 done
9631
9632   ;;
9633 esac
9634 fi
9635 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9636
9637 if test -n "$LD_FOR_TARGET"; then
9638   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9639 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9640 else
9641   echo "$as_me:$LINENO: result: no" >&5
9642 echo "${ECHO_T}no" >&6
9643 fi
9644
9645 fi
9646 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9647
9648
9649 if test -n "$LD_FOR_TARGET"; then
9650   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9651 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9652   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9653 fi
9654
9655 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9656   for ncn_progname in ld; do
9657     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9658 set dummy ${ncn_progname}; ac_word=$2
9659 echo "$as_me:$LINENO: checking for $ac_word" >&5
9660 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9661 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9662   echo $ECHO_N "(cached) $ECHO_C" >&6
9663 else
9664   if test -n "$LD_FOR_TARGET"; then
9665   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9666 else
9667 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9668 for as_dir in $PATH
9669 do
9670   IFS=$as_save_IFS
9671   test -z "$as_dir" && as_dir=.
9672   for ac_exec_ext in '' $ac_executable_extensions; do
9673   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9674     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9675     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9676     break 2
9677   fi
9678 done
9679 done
9680
9681 fi
9682 fi
9683 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9684 if test -n "$LD_FOR_TARGET"; then
9685   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9686 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9687 else
9688   echo "$as_me:$LINENO: result: no" >&5
9689 echo "${ECHO_T}no" >&6
9690 fi
9691
9692   done
9693 fi
9694
9695 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9696   for ncn_progname in ld; do
9697     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9698 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9699     if test -x $with_build_time_tools/${ncn_progname}; then
9700       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9701       echo "$as_me:$LINENO: result: yes" >&5
9702 echo "${ECHO_T}yes" >&6
9703       break
9704     else
9705       echo "$as_me:$LINENO: result: no" >&5
9706 echo "${ECHO_T}no" >&6
9707     fi
9708   done
9709 fi
9710
9711 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9712   for ncn_progname in ld; do
9713     if test -n "$ncn_target_tool_prefix"; then
9714       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9715 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9716 echo "$as_me:$LINENO: checking for $ac_word" >&5
9717 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9718 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9719   echo $ECHO_N "(cached) $ECHO_C" >&6
9720 else
9721   if test -n "$LD_FOR_TARGET"; then
9722   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9723 else
9724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9725 for as_dir in $PATH
9726 do
9727   IFS=$as_save_IFS
9728   test -z "$as_dir" && as_dir=.
9729   for ac_exec_ext in '' $ac_executable_extensions; do
9730   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9731     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9732     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9733     break 2
9734   fi
9735 done
9736 done
9737
9738 fi
9739 fi
9740 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9741 if test -n "$LD_FOR_TARGET"; then
9742   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9743 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9744 else
9745   echo "$as_me:$LINENO: result: no" >&5
9746 echo "${ECHO_T}no" >&6
9747 fi
9748
9749     fi
9750     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9751       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9752 set dummy ${ncn_progname}; ac_word=$2
9753 echo "$as_me:$LINENO: checking for $ac_word" >&5
9754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9755 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9756   echo $ECHO_N "(cached) $ECHO_C" >&6
9757 else
9758   if test -n "$LD_FOR_TARGET"; then
9759   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9760 else
9761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9762 for as_dir in $PATH
9763 do
9764   IFS=$as_save_IFS
9765   test -z "$as_dir" && as_dir=.
9766   for ac_exec_ext in '' $ac_executable_extensions; do
9767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9768     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9770     break 2
9771   fi
9772 done
9773 done
9774
9775 fi
9776 fi
9777 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9778 if test -n "$LD_FOR_TARGET"; then
9779   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9780 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9781 else
9782   echo "$as_me:$LINENO: result: no" >&5
9783 echo "${ECHO_T}no" >&6
9784 fi
9785
9786     fi
9787     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9788   done
9789 fi
9790
9791 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9792   set dummy ld
9793   if test $build = $target ; then
9794     LD_FOR_TARGET="$2"
9795   else
9796     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9797   fi
9798 else
9799   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9800 fi
9801
9802 else
9803   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9804 fi
9805
9806
9807
9808
9809 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9810   if test -n "$with_build_time_tools"; then
9811     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9812 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9813     if test -x $with_build_time_tools/lipo; then
9814       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9815       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9816       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9817 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9818     else
9819       echo "$as_me:$LINENO: result: no" >&5
9820 echo "${ECHO_T}no" >&6
9821     fi
9822   elif test $build != $host && test $have_gcc_for_target = yes; then
9823     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9824     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9825     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9826   fi
9827 fi
9828 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9829   # Extract the first word of "lipo", so it can be a program name with args.
9830 set dummy lipo; ac_word=$2
9831 echo "$as_me:$LINENO: checking for $ac_word" >&5
9832 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9833 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9834   echo $ECHO_N "(cached) $ECHO_C" >&6
9835 else
9836   case $LIPO_FOR_TARGET in
9837   [\\/]* | ?:[\\/]*)
9838   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9839   ;;
9840   *)
9841   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9842 for as_dir in $gcc_cv_tool_dirs
9843 do
9844   IFS=$as_save_IFS
9845   test -z "$as_dir" && as_dir=.
9846   for ac_exec_ext in '' $ac_executable_extensions; do
9847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9848     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9850     break 2
9851   fi
9852 done
9853 done
9854
9855   ;;
9856 esac
9857 fi
9858 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9859
9860 if test -n "$LIPO_FOR_TARGET"; then
9861   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9862 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9863 else
9864   echo "$as_me:$LINENO: result: no" >&5
9865 echo "${ECHO_T}no" >&6
9866 fi
9867
9868 fi
9869 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9870
9871
9872 if test -n "$LIPO_FOR_TARGET"; then
9873   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9874 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9875   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9876 fi
9877
9878 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9879   for ncn_progname in lipo; do
9880     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9881 set dummy ${ncn_progname}; ac_word=$2
9882 echo "$as_me:$LINENO: checking for $ac_word" >&5
9883 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9884 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9885   echo $ECHO_N "(cached) $ECHO_C" >&6
9886 else
9887   if test -n "$LIPO_FOR_TARGET"; then
9888   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9889 else
9890 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9891 for as_dir in $PATH
9892 do
9893   IFS=$as_save_IFS
9894   test -z "$as_dir" && as_dir=.
9895   for ac_exec_ext in '' $ac_executable_extensions; do
9896   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9897     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9898     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9899     break 2
9900   fi
9901 done
9902 done
9903
9904 fi
9905 fi
9906 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9907 if test -n "$LIPO_FOR_TARGET"; then
9908   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9909 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9910 else
9911   echo "$as_me:$LINENO: result: no" >&5
9912 echo "${ECHO_T}no" >&6
9913 fi
9914
9915   done
9916 fi
9917
9918 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9919   for ncn_progname in lipo; do
9920     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9921 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9922     if test -x $with_build_time_tools/${ncn_progname}; then
9923       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9924       echo "$as_me:$LINENO: result: yes" >&5
9925 echo "${ECHO_T}yes" >&6
9926       break
9927     else
9928       echo "$as_me:$LINENO: result: no" >&5
9929 echo "${ECHO_T}no" >&6
9930     fi
9931   done
9932 fi
9933
9934 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9935   for ncn_progname in lipo; do
9936     if test -n "$ncn_target_tool_prefix"; then
9937       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9938 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9939 echo "$as_me:$LINENO: checking for $ac_word" >&5
9940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9941 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9942   echo $ECHO_N "(cached) $ECHO_C" >&6
9943 else
9944   if test -n "$LIPO_FOR_TARGET"; then
9945   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9946 else
9947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9948 for as_dir in $PATH
9949 do
9950   IFS=$as_save_IFS
9951   test -z "$as_dir" && as_dir=.
9952   for ac_exec_ext in '' $ac_executable_extensions; do
9953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9954     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9956     break 2
9957   fi
9958 done
9959 done
9960
9961 fi
9962 fi
9963 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9964 if test -n "$LIPO_FOR_TARGET"; then
9965   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9966 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9967 else
9968   echo "$as_me:$LINENO: result: no" >&5
9969 echo "${ECHO_T}no" >&6
9970 fi
9971
9972     fi
9973     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9974       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9975 set dummy ${ncn_progname}; ac_word=$2
9976 echo "$as_me:$LINENO: checking for $ac_word" >&5
9977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9978 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9979   echo $ECHO_N "(cached) $ECHO_C" >&6
9980 else
9981   if test -n "$LIPO_FOR_TARGET"; then
9982   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9983 else
9984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9985 for as_dir in $PATH
9986 do
9987   IFS=$as_save_IFS
9988   test -z "$as_dir" && as_dir=.
9989   for ac_exec_ext in '' $ac_executable_extensions; do
9990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9991     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9993     break 2
9994   fi
9995 done
9996 done
9997
9998 fi
9999 fi
10000 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10001 if test -n "$LIPO_FOR_TARGET"; then
10002   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10003 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10004 else
10005   echo "$as_me:$LINENO: result: no" >&5
10006 echo "${ECHO_T}no" >&6
10007 fi
10008
10009     fi
10010     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10011   done
10012 fi
10013
10014 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10015   set dummy lipo
10016   if test $build = $target ; then
10017     LIPO_FOR_TARGET="$2"
10018   else
10019     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10020   fi
10021 else
10022   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10023 fi
10024
10025 else
10026   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10027 fi
10028
10029
10030
10031
10032 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10033   if test -n "$with_build_time_tools"; then
10034     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10035 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10036     if test -x $with_build_time_tools/nm; then
10037       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10038       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10039       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10040 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10041     else
10042       echo "$as_me:$LINENO: result: no" >&5
10043 echo "${ECHO_T}no" >&6
10044     fi
10045   elif test $build != $host && test $have_gcc_for_target = yes; then
10046     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10047     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10048     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10049   fi
10050 fi
10051 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10052   # Extract the first word of "nm", so it can be a program name with args.
10053 set dummy nm; ac_word=$2
10054 echo "$as_me:$LINENO: checking for $ac_word" >&5
10055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10056 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10057   echo $ECHO_N "(cached) $ECHO_C" >&6
10058 else
10059   case $NM_FOR_TARGET in
10060   [\\/]* | ?:[\\/]*)
10061   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10062   ;;
10063   *)
10064   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10065 for as_dir in $gcc_cv_tool_dirs
10066 do
10067   IFS=$as_save_IFS
10068   test -z "$as_dir" && as_dir=.
10069   for ac_exec_ext in '' $ac_executable_extensions; do
10070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10071     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10073     break 2
10074   fi
10075 done
10076 done
10077
10078   ;;
10079 esac
10080 fi
10081 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10082
10083 if test -n "$NM_FOR_TARGET"; then
10084   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10085 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10086 else
10087   echo "$as_me:$LINENO: result: no" >&5
10088 echo "${ECHO_T}no" >&6
10089 fi
10090
10091 fi
10092 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10093
10094
10095 if test -n "$NM_FOR_TARGET"; then
10096   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10097 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10098   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10099 fi
10100
10101 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10102   for ncn_progname in nm; do
10103     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10104 set dummy ${ncn_progname}; ac_word=$2
10105 echo "$as_me:$LINENO: checking for $ac_word" >&5
10106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10107 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10108   echo $ECHO_N "(cached) $ECHO_C" >&6
10109 else
10110   if test -n "$NM_FOR_TARGET"; then
10111   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10112 else
10113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10114 for as_dir in $PATH
10115 do
10116   IFS=$as_save_IFS
10117   test -z "$as_dir" && as_dir=.
10118   for ac_exec_ext in '' $ac_executable_extensions; do
10119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10120     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10121     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10122     break 2
10123   fi
10124 done
10125 done
10126
10127 fi
10128 fi
10129 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10130 if test -n "$NM_FOR_TARGET"; then
10131   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10132 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10133 else
10134   echo "$as_me:$LINENO: result: no" >&5
10135 echo "${ECHO_T}no" >&6
10136 fi
10137
10138   done
10139 fi
10140
10141 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10142   for ncn_progname in nm; do
10143     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10144 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10145     if test -x $with_build_time_tools/${ncn_progname}; then
10146       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10147       echo "$as_me:$LINENO: result: yes" >&5
10148 echo "${ECHO_T}yes" >&6
10149       break
10150     else
10151       echo "$as_me:$LINENO: result: no" >&5
10152 echo "${ECHO_T}no" >&6
10153     fi
10154   done
10155 fi
10156
10157 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10158   for ncn_progname in nm; do
10159     if test -n "$ncn_target_tool_prefix"; then
10160       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10161 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10162 echo "$as_me:$LINENO: checking for $ac_word" >&5
10163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10164 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10165   echo $ECHO_N "(cached) $ECHO_C" >&6
10166 else
10167   if test -n "$NM_FOR_TARGET"; then
10168   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10169 else
10170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10171 for as_dir in $PATH
10172 do
10173   IFS=$as_save_IFS
10174   test -z "$as_dir" && as_dir=.
10175   for ac_exec_ext in '' $ac_executable_extensions; do
10176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10177     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10179     break 2
10180   fi
10181 done
10182 done
10183
10184 fi
10185 fi
10186 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10187 if test -n "$NM_FOR_TARGET"; then
10188   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10189 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10190 else
10191   echo "$as_me:$LINENO: result: no" >&5
10192 echo "${ECHO_T}no" >&6
10193 fi
10194
10195     fi
10196     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10197       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10198 set dummy ${ncn_progname}; ac_word=$2
10199 echo "$as_me:$LINENO: checking for $ac_word" >&5
10200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10201 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10202   echo $ECHO_N "(cached) $ECHO_C" >&6
10203 else
10204   if test -n "$NM_FOR_TARGET"; then
10205   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10206 else
10207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10208 for as_dir in $PATH
10209 do
10210   IFS=$as_save_IFS
10211   test -z "$as_dir" && as_dir=.
10212   for ac_exec_ext in '' $ac_executable_extensions; do
10213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10214     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10216     break 2
10217   fi
10218 done
10219 done
10220
10221 fi
10222 fi
10223 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10224 if test -n "$NM_FOR_TARGET"; then
10225   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10226 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10227 else
10228   echo "$as_me:$LINENO: result: no" >&5
10229 echo "${ECHO_T}no" >&6
10230 fi
10231
10232     fi
10233     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10234   done
10235 fi
10236
10237 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10238   set dummy nm
10239   if test $build = $target ; then
10240     NM_FOR_TARGET="$2"
10241   else
10242     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10243   fi
10244 else
10245   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10246 fi
10247
10248 else
10249   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10250 fi
10251
10252
10253
10254
10255 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10256   if test -n "$with_build_time_tools"; then
10257     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10258 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10259     if test -x $with_build_time_tools/objdump; then
10260       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10261       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10262       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10263 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10264     else
10265       echo "$as_me:$LINENO: result: no" >&5
10266 echo "${ECHO_T}no" >&6
10267     fi
10268   elif test $build != $host && test $have_gcc_for_target = yes; then
10269     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10270     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10271     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10272   fi
10273 fi
10274 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10275   # Extract the first word of "objdump", so it can be a program name with args.
10276 set dummy objdump; ac_word=$2
10277 echo "$as_me:$LINENO: checking for $ac_word" >&5
10278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10279 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10280   echo $ECHO_N "(cached) $ECHO_C" >&6
10281 else
10282   case $OBJDUMP_FOR_TARGET in
10283   [\\/]* | ?:[\\/]*)
10284   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10285   ;;
10286   *)
10287   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10288 for as_dir in $gcc_cv_tool_dirs
10289 do
10290   IFS=$as_save_IFS
10291   test -z "$as_dir" && as_dir=.
10292   for ac_exec_ext in '' $ac_executable_extensions; do
10293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10294     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10296     break 2
10297   fi
10298 done
10299 done
10300
10301   ;;
10302 esac
10303 fi
10304 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10305
10306 if test -n "$OBJDUMP_FOR_TARGET"; then
10307   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10308 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10309 else
10310   echo "$as_me:$LINENO: result: no" >&5
10311 echo "${ECHO_T}no" >&6
10312 fi
10313
10314 fi
10315 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10316
10317
10318 if test -n "$OBJDUMP_FOR_TARGET"; then
10319   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10320 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10321   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10322 fi
10323
10324 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10325   for ncn_progname in objdump; do
10326     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10327 set dummy ${ncn_progname}; ac_word=$2
10328 echo "$as_me:$LINENO: checking for $ac_word" >&5
10329 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10330 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10331   echo $ECHO_N "(cached) $ECHO_C" >&6
10332 else
10333   if test -n "$OBJDUMP_FOR_TARGET"; then
10334   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10335 else
10336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10337 for as_dir in $PATH
10338 do
10339   IFS=$as_save_IFS
10340   test -z "$as_dir" && as_dir=.
10341   for ac_exec_ext in '' $ac_executable_extensions; do
10342   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10343     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10344     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10345     break 2
10346   fi
10347 done
10348 done
10349
10350 fi
10351 fi
10352 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10353 if test -n "$OBJDUMP_FOR_TARGET"; then
10354   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10355 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10356 else
10357   echo "$as_me:$LINENO: result: no" >&5
10358 echo "${ECHO_T}no" >&6
10359 fi
10360
10361   done
10362 fi
10363
10364 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10365   for ncn_progname in objdump; do
10366     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10367 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10368     if test -x $with_build_time_tools/${ncn_progname}; then
10369       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10370       echo "$as_me:$LINENO: result: yes" >&5
10371 echo "${ECHO_T}yes" >&6
10372       break
10373     else
10374       echo "$as_me:$LINENO: result: no" >&5
10375 echo "${ECHO_T}no" >&6
10376     fi
10377   done
10378 fi
10379
10380 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10381   for ncn_progname in objdump; do
10382     if test -n "$ncn_target_tool_prefix"; then
10383       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10384 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10385 echo "$as_me:$LINENO: checking for $ac_word" >&5
10386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10387 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10388   echo $ECHO_N "(cached) $ECHO_C" >&6
10389 else
10390   if test -n "$OBJDUMP_FOR_TARGET"; then
10391   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10392 else
10393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10394 for as_dir in $PATH
10395 do
10396   IFS=$as_save_IFS
10397   test -z "$as_dir" && as_dir=.
10398   for ac_exec_ext in '' $ac_executable_extensions; do
10399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10400     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10402     break 2
10403   fi
10404 done
10405 done
10406
10407 fi
10408 fi
10409 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10410 if test -n "$OBJDUMP_FOR_TARGET"; then
10411   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10412 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10413 else
10414   echo "$as_me:$LINENO: result: no" >&5
10415 echo "${ECHO_T}no" >&6
10416 fi
10417
10418     fi
10419     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10420       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10421 set dummy ${ncn_progname}; ac_word=$2
10422 echo "$as_me:$LINENO: checking for $ac_word" >&5
10423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10424 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10425   echo $ECHO_N "(cached) $ECHO_C" >&6
10426 else
10427   if test -n "$OBJDUMP_FOR_TARGET"; then
10428   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10429 else
10430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10431 for as_dir in $PATH
10432 do
10433   IFS=$as_save_IFS
10434   test -z "$as_dir" && as_dir=.
10435   for ac_exec_ext in '' $ac_executable_extensions; do
10436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10437     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10439     break 2
10440   fi
10441 done
10442 done
10443
10444 fi
10445 fi
10446 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10447 if test -n "$OBJDUMP_FOR_TARGET"; then
10448   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10449 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10450 else
10451   echo "$as_me:$LINENO: result: no" >&5
10452 echo "${ECHO_T}no" >&6
10453 fi
10454
10455     fi
10456     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10457   done
10458 fi
10459
10460 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10461   set dummy objdump
10462   if test $build = $target ; then
10463     OBJDUMP_FOR_TARGET="$2"
10464   else
10465     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10466   fi
10467 else
10468   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10469 fi
10470
10471 else
10472   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10473 fi
10474
10475
10476
10477
10478 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10479   if test -n "$with_build_time_tools"; then
10480     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10481 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10482     if test -x $with_build_time_tools/ranlib; then
10483       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10484       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10485       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10486 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10487     else
10488       echo "$as_me:$LINENO: result: no" >&5
10489 echo "${ECHO_T}no" >&6
10490     fi
10491   elif test $build != $host && test $have_gcc_for_target = yes; then
10492     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10493     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10494     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10495   fi
10496 fi
10497 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10498   # Extract the first word of "ranlib", so it can be a program name with args.
10499 set dummy ranlib; ac_word=$2
10500 echo "$as_me:$LINENO: checking for $ac_word" >&5
10501 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10502 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10503   echo $ECHO_N "(cached) $ECHO_C" >&6
10504 else
10505   case $RANLIB_FOR_TARGET in
10506   [\\/]* | ?:[\\/]*)
10507   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10508   ;;
10509   *)
10510   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10511 for as_dir in $gcc_cv_tool_dirs
10512 do
10513   IFS=$as_save_IFS
10514   test -z "$as_dir" && as_dir=.
10515   for ac_exec_ext in '' $ac_executable_extensions; do
10516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10517     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10519     break 2
10520   fi
10521 done
10522 done
10523
10524   ;;
10525 esac
10526 fi
10527 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10528
10529 if test -n "$RANLIB_FOR_TARGET"; then
10530   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10531 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10532 else
10533   echo "$as_me:$LINENO: result: no" >&5
10534 echo "${ECHO_T}no" >&6
10535 fi
10536
10537 fi
10538 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10539
10540
10541 if test -n "$RANLIB_FOR_TARGET"; then
10542   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10543 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10544   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10545 fi
10546
10547 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10548   for ncn_progname in ranlib; do
10549     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10550 set dummy ${ncn_progname}; ac_word=$2
10551 echo "$as_me:$LINENO: checking for $ac_word" >&5
10552 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10553 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10554   echo $ECHO_N "(cached) $ECHO_C" >&6
10555 else
10556   if test -n "$RANLIB_FOR_TARGET"; then
10557   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10558 else
10559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10560 for as_dir in $PATH
10561 do
10562   IFS=$as_save_IFS
10563   test -z "$as_dir" && as_dir=.
10564   for ac_exec_ext in '' $ac_executable_extensions; do
10565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10566     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10568     break 2
10569   fi
10570 done
10571 done
10572
10573 fi
10574 fi
10575 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10576 if test -n "$RANLIB_FOR_TARGET"; then
10577   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10578 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10579 else
10580   echo "$as_me:$LINENO: result: no" >&5
10581 echo "${ECHO_T}no" >&6
10582 fi
10583
10584   done
10585 fi
10586
10587 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10588   for ncn_progname in ranlib; do
10589     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10590 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10591     if test -x $with_build_time_tools/${ncn_progname}; then
10592       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10593       echo "$as_me:$LINENO: result: yes" >&5
10594 echo "${ECHO_T}yes" >&6
10595       break
10596     else
10597       echo "$as_me:$LINENO: result: no" >&5
10598 echo "${ECHO_T}no" >&6
10599     fi
10600   done
10601 fi
10602
10603 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10604   for ncn_progname in ranlib; do
10605     if test -n "$ncn_target_tool_prefix"; then
10606       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10607 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10608 echo "$as_me:$LINENO: checking for $ac_word" >&5
10609 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10610 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10611   echo $ECHO_N "(cached) $ECHO_C" >&6
10612 else
10613   if test -n "$RANLIB_FOR_TARGET"; then
10614   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10615 else
10616 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10617 for as_dir in $PATH
10618 do
10619   IFS=$as_save_IFS
10620   test -z "$as_dir" && as_dir=.
10621   for ac_exec_ext in '' $ac_executable_extensions; do
10622   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10623     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10624     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10625     break 2
10626   fi
10627 done
10628 done
10629
10630 fi
10631 fi
10632 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10633 if test -n "$RANLIB_FOR_TARGET"; then
10634   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10635 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10636 else
10637   echo "$as_me:$LINENO: result: no" >&5
10638 echo "${ECHO_T}no" >&6
10639 fi
10640
10641     fi
10642     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10643       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10644 set dummy ${ncn_progname}; ac_word=$2
10645 echo "$as_me:$LINENO: checking for $ac_word" >&5
10646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10647 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10648   echo $ECHO_N "(cached) $ECHO_C" >&6
10649 else
10650   if test -n "$RANLIB_FOR_TARGET"; then
10651   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10652 else
10653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10654 for as_dir in $PATH
10655 do
10656   IFS=$as_save_IFS
10657   test -z "$as_dir" && as_dir=.
10658   for ac_exec_ext in '' $ac_executable_extensions; do
10659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10660     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10662     break 2
10663   fi
10664 done
10665 done
10666
10667 fi
10668 fi
10669 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10670 if test -n "$RANLIB_FOR_TARGET"; then
10671   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10672 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10673 else
10674   echo "$as_me:$LINENO: result: no" >&5
10675 echo "${ECHO_T}no" >&6
10676 fi
10677
10678     fi
10679     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10680   done
10681 fi
10682
10683 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10684   set dummy ranlib
10685   if test $build = $target ; then
10686     RANLIB_FOR_TARGET="$2"
10687   else
10688     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10689   fi
10690 else
10691   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10692 fi
10693
10694 else
10695   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10696 fi
10697
10698
10699
10700
10701 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10702   if test -n "$with_build_time_tools"; then
10703     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10704 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10705     if test -x $with_build_time_tools/strip; then
10706       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10707       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10708       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10709 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10710     else
10711       echo "$as_me:$LINENO: result: no" >&5
10712 echo "${ECHO_T}no" >&6
10713     fi
10714   elif test $build != $host && test $have_gcc_for_target = yes; then
10715     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10716     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10717     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10718   fi
10719 fi
10720 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10721   # Extract the first word of "strip", so it can be a program name with args.
10722 set dummy strip; ac_word=$2
10723 echo "$as_me:$LINENO: checking for $ac_word" >&5
10724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10725 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10726   echo $ECHO_N "(cached) $ECHO_C" >&6
10727 else
10728   case $STRIP_FOR_TARGET in
10729   [\\/]* | ?:[\\/]*)
10730   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10731   ;;
10732   *)
10733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10734 for as_dir in $gcc_cv_tool_dirs
10735 do
10736   IFS=$as_save_IFS
10737   test -z "$as_dir" && as_dir=.
10738   for ac_exec_ext in '' $ac_executable_extensions; do
10739   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10740     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10741     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10742     break 2
10743   fi
10744 done
10745 done
10746
10747   ;;
10748 esac
10749 fi
10750 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10751
10752 if test -n "$STRIP_FOR_TARGET"; then
10753   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10754 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10755 else
10756   echo "$as_me:$LINENO: result: no" >&5
10757 echo "${ECHO_T}no" >&6
10758 fi
10759
10760 fi
10761 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10762
10763
10764 if test -n "$STRIP_FOR_TARGET"; then
10765   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10766 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10767   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10768 fi
10769
10770 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10771   for ncn_progname in strip; do
10772     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10773 set dummy ${ncn_progname}; ac_word=$2
10774 echo "$as_me:$LINENO: checking for $ac_word" >&5
10775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10776 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10777   echo $ECHO_N "(cached) $ECHO_C" >&6
10778 else
10779   if test -n "$STRIP_FOR_TARGET"; then
10780   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10781 else
10782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10783 for as_dir in $PATH
10784 do
10785   IFS=$as_save_IFS
10786   test -z "$as_dir" && as_dir=.
10787   for ac_exec_ext in '' $ac_executable_extensions; do
10788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10789     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10791     break 2
10792   fi
10793 done
10794 done
10795
10796 fi
10797 fi
10798 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10799 if test -n "$STRIP_FOR_TARGET"; then
10800   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10801 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10802 else
10803   echo "$as_me:$LINENO: result: no" >&5
10804 echo "${ECHO_T}no" >&6
10805 fi
10806
10807   done
10808 fi
10809
10810 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10811   for ncn_progname in strip; do
10812     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10813 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10814     if test -x $with_build_time_tools/${ncn_progname}; then
10815       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10816       echo "$as_me:$LINENO: result: yes" >&5
10817 echo "${ECHO_T}yes" >&6
10818       break
10819     else
10820       echo "$as_me:$LINENO: result: no" >&5
10821 echo "${ECHO_T}no" >&6
10822     fi
10823   done
10824 fi
10825
10826 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10827   for ncn_progname in strip; do
10828     if test -n "$ncn_target_tool_prefix"; then
10829       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10830 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10831 echo "$as_me:$LINENO: checking for $ac_word" >&5
10832 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10833 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10834   echo $ECHO_N "(cached) $ECHO_C" >&6
10835 else
10836   if test -n "$STRIP_FOR_TARGET"; then
10837   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10838 else
10839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10840 for as_dir in $PATH
10841 do
10842   IFS=$as_save_IFS
10843   test -z "$as_dir" && as_dir=.
10844   for ac_exec_ext in '' $ac_executable_extensions; do
10845   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10846     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10847     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10848     break 2
10849   fi
10850 done
10851 done
10852
10853 fi
10854 fi
10855 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10856 if test -n "$STRIP_FOR_TARGET"; then
10857   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10858 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10859 else
10860   echo "$as_me:$LINENO: result: no" >&5
10861 echo "${ECHO_T}no" >&6
10862 fi
10863
10864     fi
10865     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10866       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10867 set dummy ${ncn_progname}; ac_word=$2
10868 echo "$as_me:$LINENO: checking for $ac_word" >&5
10869 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10870 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10871   echo $ECHO_N "(cached) $ECHO_C" >&6
10872 else
10873   if test -n "$STRIP_FOR_TARGET"; then
10874   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10875 else
10876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10877 for as_dir in $PATH
10878 do
10879   IFS=$as_save_IFS
10880   test -z "$as_dir" && as_dir=.
10881   for ac_exec_ext in '' $ac_executable_extensions; do
10882   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10883     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10884     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10885     break 2
10886   fi
10887 done
10888 done
10889
10890 fi
10891 fi
10892 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10893 if test -n "$STRIP_FOR_TARGET"; then
10894   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10895 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10896 else
10897   echo "$as_me:$LINENO: result: no" >&5
10898 echo "${ECHO_T}no" >&6
10899 fi
10900
10901     fi
10902     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10903   done
10904 fi
10905
10906 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10907   set dummy strip
10908   if test $build = $target ; then
10909     STRIP_FOR_TARGET="$2"
10910   else
10911     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10912   fi
10913 else
10914   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10915 fi
10916
10917 else
10918   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10919 fi
10920
10921
10922
10923
10924 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10925   if test -n "$with_build_time_tools"; then
10926     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10927 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10928     if test -x $with_build_time_tools/windres; then
10929       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10930       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10931       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10932 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10933     else
10934       echo "$as_me:$LINENO: result: no" >&5
10935 echo "${ECHO_T}no" >&6
10936     fi
10937   elif test $build != $host && test $have_gcc_for_target = yes; then
10938     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10939     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10940     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10941   fi
10942 fi
10943 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10944   # Extract the first word of "windres", so it can be a program name with args.
10945 set dummy windres; ac_word=$2
10946 echo "$as_me:$LINENO: checking for $ac_word" >&5
10947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10948 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10949   echo $ECHO_N "(cached) $ECHO_C" >&6
10950 else
10951   case $WINDRES_FOR_TARGET in
10952   [\\/]* | ?:[\\/]*)
10953   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10954   ;;
10955   *)
10956   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10957 for as_dir in $gcc_cv_tool_dirs
10958 do
10959   IFS=$as_save_IFS
10960   test -z "$as_dir" && as_dir=.
10961   for ac_exec_ext in '' $ac_executable_extensions; do
10962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10963     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10965     break 2
10966   fi
10967 done
10968 done
10969
10970   ;;
10971 esac
10972 fi
10973 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10974
10975 if test -n "$WINDRES_FOR_TARGET"; then
10976   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10977 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10978 else
10979   echo "$as_me:$LINENO: result: no" >&5
10980 echo "${ECHO_T}no" >&6
10981 fi
10982
10983 fi
10984 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10985
10986
10987 if test -n "$WINDRES_FOR_TARGET"; then
10988   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10989 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10990   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10991 fi
10992
10993 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10994   for ncn_progname in windres; do
10995     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10996 set dummy ${ncn_progname}; ac_word=$2
10997 echo "$as_me:$LINENO: checking for $ac_word" >&5
10998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10999 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11000   echo $ECHO_N "(cached) $ECHO_C" >&6
11001 else
11002   if test -n "$WINDRES_FOR_TARGET"; then
11003   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11004 else
11005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11006 for as_dir in $PATH
11007 do
11008   IFS=$as_save_IFS
11009   test -z "$as_dir" && as_dir=.
11010   for ac_exec_ext in '' $ac_executable_extensions; do
11011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11012     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11014     break 2
11015   fi
11016 done
11017 done
11018
11019 fi
11020 fi
11021 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11022 if test -n "$WINDRES_FOR_TARGET"; then
11023   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11024 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11025 else
11026   echo "$as_me:$LINENO: result: no" >&5
11027 echo "${ECHO_T}no" >&6
11028 fi
11029
11030   done
11031 fi
11032
11033 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11034   for ncn_progname in windres; do
11035     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11036 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11037     if test -x $with_build_time_tools/${ncn_progname}; then
11038       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11039       echo "$as_me:$LINENO: result: yes" >&5
11040 echo "${ECHO_T}yes" >&6
11041       break
11042     else
11043       echo "$as_me:$LINENO: result: no" >&5
11044 echo "${ECHO_T}no" >&6
11045     fi
11046   done
11047 fi
11048
11049 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11050   for ncn_progname in windres; do
11051     if test -n "$ncn_target_tool_prefix"; then
11052       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11053 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11054 echo "$as_me:$LINENO: checking for $ac_word" >&5
11055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11056 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11057   echo $ECHO_N "(cached) $ECHO_C" >&6
11058 else
11059   if test -n "$WINDRES_FOR_TARGET"; then
11060   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11061 else
11062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11063 for as_dir in $PATH
11064 do
11065   IFS=$as_save_IFS
11066   test -z "$as_dir" && as_dir=.
11067   for ac_exec_ext in '' $ac_executable_extensions; do
11068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11069     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11070     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11071     break 2
11072   fi
11073 done
11074 done
11075
11076 fi
11077 fi
11078 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11079 if test -n "$WINDRES_FOR_TARGET"; then
11080   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11081 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11082 else
11083   echo "$as_me:$LINENO: result: no" >&5
11084 echo "${ECHO_T}no" >&6
11085 fi
11086
11087     fi
11088     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11089       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11090 set dummy ${ncn_progname}; ac_word=$2
11091 echo "$as_me:$LINENO: checking for $ac_word" >&5
11092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11093 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11094   echo $ECHO_N "(cached) $ECHO_C" >&6
11095 else
11096   if test -n "$WINDRES_FOR_TARGET"; then
11097   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11098 else
11099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11100 for as_dir in $PATH
11101 do
11102   IFS=$as_save_IFS
11103   test -z "$as_dir" && as_dir=.
11104   for ac_exec_ext in '' $ac_executable_extensions; do
11105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11106     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11108     break 2
11109   fi
11110 done
11111 done
11112
11113 fi
11114 fi
11115 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11116 if test -n "$WINDRES_FOR_TARGET"; then
11117   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11118 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11119 else
11120   echo "$as_me:$LINENO: result: no" >&5
11121 echo "${ECHO_T}no" >&6
11122 fi
11123
11124     fi
11125     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11126   done
11127 fi
11128
11129 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11130   set dummy windres
11131   if test $build = $target ; then
11132     WINDRES_FOR_TARGET="$2"
11133   else
11134     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11135   fi
11136 else
11137   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11138 fi
11139
11140 else
11141   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11142 fi
11143
11144
11145
11146
11147 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11148   if test -n "$with_build_time_tools"; then
11149     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11150 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11151     if test -x $with_build_time_tools/windmc; then
11152       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11153       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11154       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11155 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11156     else
11157       echo "$as_me:$LINENO: result: no" >&5
11158 echo "${ECHO_T}no" >&6
11159     fi
11160   elif test $build != $host && test $have_gcc_for_target = yes; then
11161     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11162     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11163     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11164   fi
11165 fi
11166 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11167   # Extract the first word of "windmc", so it can be a program name with args.
11168 set dummy windmc; ac_word=$2
11169 echo "$as_me:$LINENO: checking for $ac_word" >&5
11170 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11171 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11172   echo $ECHO_N "(cached) $ECHO_C" >&6
11173 else
11174   case $WINDMC_FOR_TARGET in
11175   [\\/]* | ?:[\\/]*)
11176   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11177   ;;
11178   *)
11179   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11180 for as_dir in $gcc_cv_tool_dirs
11181 do
11182   IFS=$as_save_IFS
11183   test -z "$as_dir" && as_dir=.
11184   for ac_exec_ext in '' $ac_executable_extensions; do
11185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11186     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11187     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11188     break 2
11189   fi
11190 done
11191 done
11192
11193   ;;
11194 esac
11195 fi
11196 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11197
11198 if test -n "$WINDMC_FOR_TARGET"; then
11199   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11200 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11201 else
11202   echo "$as_me:$LINENO: result: no" >&5
11203 echo "${ECHO_T}no" >&6
11204 fi
11205
11206 fi
11207 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11208
11209
11210 if test -n "$WINDMC_FOR_TARGET"; then
11211   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11212 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11213   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11214 fi
11215
11216 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11217   for ncn_progname in windmc; do
11218     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11219 set dummy ${ncn_progname}; ac_word=$2
11220 echo "$as_me:$LINENO: checking for $ac_word" >&5
11221 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11222 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11223   echo $ECHO_N "(cached) $ECHO_C" >&6
11224 else
11225   if test -n "$WINDMC_FOR_TARGET"; then
11226   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11227 else
11228 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11229 for as_dir in $PATH
11230 do
11231   IFS=$as_save_IFS
11232   test -z "$as_dir" && as_dir=.
11233   for ac_exec_ext in '' $ac_executable_extensions; do
11234   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11235     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11236     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11237     break 2
11238   fi
11239 done
11240 done
11241
11242 fi
11243 fi
11244 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11245 if test -n "$WINDMC_FOR_TARGET"; then
11246   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11247 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11248 else
11249   echo "$as_me:$LINENO: result: no" >&5
11250 echo "${ECHO_T}no" >&6
11251 fi
11252
11253   done
11254 fi
11255
11256 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11257   for ncn_progname in windmc; do
11258     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11259 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11260     if test -x $with_build_time_tools/${ncn_progname}; then
11261       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11262       echo "$as_me:$LINENO: result: yes" >&5
11263 echo "${ECHO_T}yes" >&6
11264       break
11265     else
11266       echo "$as_me:$LINENO: result: no" >&5
11267 echo "${ECHO_T}no" >&6
11268     fi
11269   done
11270 fi
11271
11272 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11273   for ncn_progname in windmc; do
11274     if test -n "$ncn_target_tool_prefix"; then
11275       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11276 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11277 echo "$as_me:$LINENO: checking for $ac_word" >&5
11278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11279 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11280   echo $ECHO_N "(cached) $ECHO_C" >&6
11281 else
11282   if test -n "$WINDMC_FOR_TARGET"; then
11283   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11284 else
11285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11286 for as_dir in $PATH
11287 do
11288   IFS=$as_save_IFS
11289   test -z "$as_dir" && as_dir=.
11290   for ac_exec_ext in '' $ac_executable_extensions; do
11291   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11292     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11293     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11294     break 2
11295   fi
11296 done
11297 done
11298
11299 fi
11300 fi
11301 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11302 if test -n "$WINDMC_FOR_TARGET"; then
11303   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11304 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11305 else
11306   echo "$as_me:$LINENO: result: no" >&5
11307 echo "${ECHO_T}no" >&6
11308 fi
11309
11310     fi
11311     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11312       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11313 set dummy ${ncn_progname}; ac_word=$2
11314 echo "$as_me:$LINENO: checking for $ac_word" >&5
11315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11316 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11317   echo $ECHO_N "(cached) $ECHO_C" >&6
11318 else
11319   if test -n "$WINDMC_FOR_TARGET"; then
11320   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11321 else
11322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11323 for as_dir in $PATH
11324 do
11325   IFS=$as_save_IFS
11326   test -z "$as_dir" && as_dir=.
11327   for ac_exec_ext in '' $ac_executable_extensions; do
11328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11329     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11331     break 2
11332   fi
11333 done
11334 done
11335
11336 fi
11337 fi
11338 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11339 if test -n "$WINDMC_FOR_TARGET"; then
11340   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11341 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11342 else
11343   echo "$as_me:$LINENO: result: no" >&5
11344 echo "${ECHO_T}no" >&6
11345 fi
11346
11347     fi
11348     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11349   done
11350 fi
11351
11352 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11353   set dummy windmc
11354   if test $build = $target ; then
11355     WINDMC_FOR_TARGET="$2"
11356   else
11357     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11358   fi
11359 else
11360   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11361 fi
11362
11363 else
11364   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11365 fi
11366
11367
11368 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11369
11370 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11371 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11372 if test "x${build}" != "x${host}" ; then
11373   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11374     # We already found the complete path
11375     ac_dir=`dirname $AR_FOR_TARGET`
11376     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11377 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11378   else
11379     # Canadian cross, just use what we found
11380     echo "$as_me:$LINENO: result: pre-installed" >&5
11381 echo "${ECHO_T}pre-installed" >&6
11382   fi
11383 else
11384   ok=yes
11385   case " ${configdirs} " in
11386     *" binutils "*) ;;
11387     *) ok=no ;;
11388   esac
11389
11390   if test $ok = yes; then
11391     # An in-tree tool is available and we can use it
11392     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11393     echo "$as_me:$LINENO: result: just compiled" >&5
11394 echo "${ECHO_T}just compiled" >&6
11395   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11396     # We already found the complete path
11397     ac_dir=`dirname $AR_FOR_TARGET`
11398     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11399 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11400   elif test "x$target" = "x$host"; then
11401     # We can use an host tool
11402     AR_FOR_TARGET='$(AR)'
11403     echo "$as_me:$LINENO: result: host tool" >&5
11404 echo "${ECHO_T}host tool" >&6
11405   else
11406     # We need a cross tool
11407     echo "$as_me:$LINENO: result: pre-installed" >&5
11408 echo "${ECHO_T}pre-installed" >&6
11409   fi
11410 fi
11411
11412 echo "$as_me:$LINENO: checking where to find the target as" >&5
11413 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11414 if test "x${build}" != "x${host}" ; then
11415   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11416     # We already found the complete path
11417     ac_dir=`dirname $AS_FOR_TARGET`
11418     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11419 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11420   else
11421     # Canadian cross, just use what we found
11422     echo "$as_me:$LINENO: result: pre-installed" >&5
11423 echo "${ECHO_T}pre-installed" >&6
11424   fi
11425 else
11426   ok=yes
11427   case " ${configdirs} " in
11428     *" gas "*) ;;
11429     *) ok=no ;;
11430   esac
11431
11432   if test $ok = yes; then
11433     # An in-tree tool is available and we can use it
11434     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11435     echo "$as_me:$LINENO: result: just compiled" >&5
11436 echo "${ECHO_T}just compiled" >&6
11437   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11438     # We already found the complete path
11439     ac_dir=`dirname $AS_FOR_TARGET`
11440     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11441 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11442   elif test "x$target" = "x$host"; then
11443     # We can use an host tool
11444     AS_FOR_TARGET='$(AS)'
11445     echo "$as_me:$LINENO: result: host tool" >&5
11446 echo "${ECHO_T}host tool" >&6
11447   else
11448     # We need a cross tool
11449     echo "$as_me:$LINENO: result: pre-installed" >&5
11450 echo "${ECHO_T}pre-installed" >&6
11451   fi
11452 fi
11453
11454 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11455 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11456 if test "x${build}" != "x${host}" ; then
11457   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11458     # We already found the complete path
11459     ac_dir=`dirname $CC_FOR_TARGET`
11460     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11461 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11462   else
11463     # Canadian cross, just use what we found
11464     echo "$as_me:$LINENO: result: pre-installed" >&5
11465 echo "${ECHO_T}pre-installed" >&6
11466   fi
11467 else
11468   ok=yes
11469   case " ${configdirs} " in
11470     *" gcc "*) ;;
11471     *) ok=no ;;
11472   esac
11473
11474   if test $ok = yes; then
11475     # An in-tree tool is available and we can use it
11476     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11477     echo "$as_me:$LINENO: result: just compiled" >&5
11478 echo "${ECHO_T}just compiled" >&6
11479   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11480     # We already found the complete path
11481     ac_dir=`dirname $CC_FOR_TARGET`
11482     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11483 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11484   elif test "x$target" = "x$host"; then
11485     # We can use an host tool
11486     CC_FOR_TARGET='$(CC)'
11487     echo "$as_me:$LINENO: result: host tool" >&5
11488 echo "${ECHO_T}host tool" >&6
11489   else
11490     # We need a cross tool
11491     echo "$as_me:$LINENO: result: pre-installed" >&5
11492 echo "${ECHO_T}pre-installed" >&6
11493   fi
11494 fi
11495
11496 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11497 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11498 if test "x${build}" != "x${host}" ; then
11499   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11500     # We already found the complete path
11501     ac_dir=`dirname $CXX_FOR_TARGET`
11502     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11503 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11504   else
11505     # Canadian cross, just use what we found
11506     echo "$as_me:$LINENO: result: pre-installed" >&5
11507 echo "${ECHO_T}pre-installed" >&6
11508   fi
11509 else
11510   ok=yes
11511   case " ${configdirs} " in
11512     *" gcc "*) ;;
11513     *) ok=no ;;
11514   esac
11515   case ,${enable_languages}, in
11516     *,c++,*) ;;
11517     *) ok=no ;;
11518   esac
11519   if test $ok = yes; then
11520     # An in-tree tool is available and we can use it
11521     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'
11522     echo "$as_me:$LINENO: result: just compiled" >&5
11523 echo "${ECHO_T}just compiled" >&6
11524   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11525     # We already found the complete path
11526     ac_dir=`dirname $CXX_FOR_TARGET`
11527     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11528 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11529   elif test "x$target" = "x$host"; then
11530     # We can use an host tool
11531     CXX_FOR_TARGET='$(CXX)'
11532     echo "$as_me:$LINENO: result: host tool" >&5
11533 echo "${ECHO_T}host tool" >&6
11534   else
11535     # We need a cross tool
11536     echo "$as_me:$LINENO: result: pre-installed" >&5
11537 echo "${ECHO_T}pre-installed" >&6
11538   fi
11539 fi
11540
11541 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11542 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11543 if test "x${build}" != "x${host}" ; then
11544   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11545     # We already found the complete path
11546     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11547     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11548 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11549   else
11550     # Canadian cross, just use what we found
11551     echo "$as_me:$LINENO: result: pre-installed" >&5
11552 echo "${ECHO_T}pre-installed" >&6
11553   fi
11554 else
11555   ok=yes
11556   case " ${configdirs} " in
11557     *" gcc "*) ;;
11558     *) ok=no ;;
11559   esac
11560   case ,${enable_languages}, in
11561     *,c++,*) ;;
11562     *) ok=no ;;
11563   esac
11564   if test $ok = yes; then
11565     # An in-tree tool is available and we can use it
11566     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'
11567     echo "$as_me:$LINENO: result: just compiled" >&5
11568 echo "${ECHO_T}just compiled" >&6
11569   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11570     # We already found the complete path
11571     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11572     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11573 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11574   elif test "x$target" = "x$host"; then
11575     # We can use an host tool
11576     RAW_CXX_FOR_TARGET='$(CXX)'
11577     echo "$as_me:$LINENO: result: host tool" >&5
11578 echo "${ECHO_T}host tool" >&6
11579   else
11580     # We need a cross tool
11581     echo "$as_me:$LINENO: result: pre-installed" >&5
11582 echo "${ECHO_T}pre-installed" >&6
11583   fi
11584 fi
11585
11586 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11587 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11588 if test "x${build}" != "x${host}" ; then
11589   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11590     # We already found the complete path
11591     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11592     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11593 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11594   else
11595     # Canadian cross, just use what we found
11596     echo "$as_me:$LINENO: result: pre-installed" >&5
11597 echo "${ECHO_T}pre-installed" >&6
11598   fi
11599 else
11600   ok=yes
11601   case " ${configdirs} " in
11602     *" binutils "*) ;;
11603     *) ok=no ;;
11604   esac
11605
11606   if test $ok = yes; then
11607     # An in-tree tool is available and we can use it
11608     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11609     echo "$as_me:$LINENO: result: just compiled" >&5
11610 echo "${ECHO_T}just compiled" >&6
11611   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11612     # We already found the complete path
11613     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11614     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11615 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11616   elif test "x$target" = "x$host"; then
11617     # We can use an host tool
11618     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11619     echo "$as_me:$LINENO: result: host tool" >&5
11620 echo "${ECHO_T}host tool" >&6
11621   else
11622     # We need a cross tool
11623     echo "$as_me:$LINENO: result: pre-installed" >&5
11624 echo "${ECHO_T}pre-installed" >&6
11625   fi
11626 fi
11627
11628 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11629 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11630 if test "x${build}" != "x${host}" ; then
11631   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11632     # We already found the complete path
11633     ac_dir=`dirname $GCC_FOR_TARGET`
11634     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11635 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11636   else
11637     # Canadian cross, just use what we found
11638     echo "$as_me:$LINENO: result: pre-installed" >&5
11639 echo "${ECHO_T}pre-installed" >&6
11640   fi
11641 else
11642   ok=yes
11643   case " ${configdirs} " in
11644     *" gcc "*) ;;
11645     *) ok=no ;;
11646   esac
11647
11648   if test $ok = yes; then
11649     # An in-tree tool is available and we can use it
11650     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11651     echo "$as_me:$LINENO: result: just compiled" >&5
11652 echo "${ECHO_T}just compiled" >&6
11653   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11654     # We already found the complete path
11655     ac_dir=`dirname $GCC_FOR_TARGET`
11656     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11657 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11658   elif test "x$target" = "x$host"; then
11659     # We can use an host tool
11660     GCC_FOR_TARGET='$()'
11661     echo "$as_me:$LINENO: result: host tool" >&5
11662 echo "${ECHO_T}host tool" >&6
11663   else
11664     # We need a cross tool
11665     echo "$as_me:$LINENO: result: pre-installed" >&5
11666 echo "${ECHO_T}pre-installed" >&6
11667   fi
11668 fi
11669
11670 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11671 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11672 if test "x${build}" != "x${host}" ; then
11673   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11674     # We already found the complete path
11675     ac_dir=`dirname $GCJ_FOR_TARGET`
11676     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11677 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11678   else
11679     # Canadian cross, just use what we found
11680     echo "$as_me:$LINENO: result: pre-installed" >&5
11681 echo "${ECHO_T}pre-installed" >&6
11682   fi
11683 else
11684   ok=yes
11685   case " ${configdirs} " in
11686     *" gcc "*) ;;
11687     *) ok=no ;;
11688   esac
11689   case ,${enable_languages}, in
11690     *,java,*) ;;
11691     *) ok=no ;;
11692   esac
11693   if test $ok = yes; then
11694     # An in-tree tool is available and we can use it
11695     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11696     echo "$as_me:$LINENO: result: just compiled" >&5
11697 echo "${ECHO_T}just compiled" >&6
11698   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11699     # We already found the complete path
11700     ac_dir=`dirname $GCJ_FOR_TARGET`
11701     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11702 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11703   elif test "x$target" = "x$host"; then
11704     # We can use an host tool
11705     GCJ_FOR_TARGET='$(GCJ)'
11706     echo "$as_me:$LINENO: result: host tool" >&5
11707 echo "${ECHO_T}host tool" >&6
11708   else
11709     # We need a cross tool
11710     echo "$as_me:$LINENO: result: pre-installed" >&5
11711 echo "${ECHO_T}pre-installed" >&6
11712   fi
11713 fi
11714
11715 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11716 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11717 if test "x${build}" != "x${host}" ; then
11718   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11719     # We already found the complete path
11720     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11721     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11722 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11723   else
11724     # Canadian cross, just use what we found
11725     echo "$as_me:$LINENO: result: pre-installed" >&5
11726 echo "${ECHO_T}pre-installed" >&6
11727   fi
11728 else
11729   ok=yes
11730   case " ${configdirs} " in
11731     *" gcc "*) ;;
11732     *) ok=no ;;
11733   esac
11734   case ,${enable_languages}, in
11735     *,fortran,*) ;;
11736     *) ok=no ;;
11737   esac
11738   if test $ok = yes; then
11739     # An in-tree tool is available and we can use it
11740     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11741     echo "$as_me:$LINENO: result: just compiled" >&5
11742 echo "${ECHO_T}just compiled" >&6
11743   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11744     # We already found the complete path
11745     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11746     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11747 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11748   elif test "x$target" = "x$host"; then
11749     # We can use an host tool
11750     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11751     echo "$as_me:$LINENO: result: host tool" >&5
11752 echo "${ECHO_T}host tool" >&6
11753   else
11754     # We need a cross tool
11755     echo "$as_me:$LINENO: result: pre-installed" >&5
11756 echo "${ECHO_T}pre-installed" >&6
11757   fi
11758 fi
11759
11760 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11761 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11762 if test "x${build}" != "x${host}" ; then
11763   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11764     # We already found the complete path
11765     ac_dir=`dirname $LD_FOR_TARGET`
11766     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11767 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11768   else
11769     # Canadian cross, just use what we found
11770     echo "$as_me:$LINENO: result: pre-installed" >&5
11771 echo "${ECHO_T}pre-installed" >&6
11772   fi
11773 else
11774   ok=yes
11775   case " ${configdirs} " in
11776     *" ld "*) ;;
11777     *) ok=no ;;
11778   esac
11779
11780   if test $ok = yes; then
11781     # An in-tree tool is available and we can use it
11782     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11783     echo "$as_me:$LINENO: result: just compiled" >&5
11784 echo "${ECHO_T}just compiled" >&6
11785   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11786     # We already found the complete path
11787     ac_dir=`dirname $LD_FOR_TARGET`
11788     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11789 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11790   elif test "x$target" = "x$host"; then
11791     # We can use an host tool
11792     LD_FOR_TARGET='$(LD)'
11793     echo "$as_me:$LINENO: result: host tool" >&5
11794 echo "${ECHO_T}host tool" >&6
11795   else
11796     # We need a cross tool
11797     echo "$as_me:$LINENO: result: pre-installed" >&5
11798 echo "${ECHO_T}pre-installed" >&6
11799   fi
11800 fi
11801
11802 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11803 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11804 if test "x${build}" != "x${host}" ; then
11805   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11806     # We already found the complete path
11807     ac_dir=`dirname $LIPO_FOR_TARGET`
11808     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11809 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11810   else
11811     # Canadian cross, just use what we found
11812     echo "$as_me:$LINENO: result: pre-installed" >&5
11813 echo "${ECHO_T}pre-installed" >&6
11814   fi
11815 else
11816   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11817     # We already found the complete path
11818     ac_dir=`dirname $LIPO_FOR_TARGET`
11819     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11820 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11821   elif test "x$target" = "x$host"; then
11822     # We can use an host tool
11823     LIPO_FOR_TARGET='$(LIPO)'
11824     echo "$as_me:$LINENO: result: host tool" >&5
11825 echo "${ECHO_T}host tool" >&6
11826   else
11827     # We need a cross tool
11828     echo "$as_me:$LINENO: result: pre-installed" >&5
11829 echo "${ECHO_T}pre-installed" >&6
11830   fi
11831 fi
11832
11833 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11834 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11835 if test "x${build}" != "x${host}" ; then
11836   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11837     # We already found the complete path
11838     ac_dir=`dirname $NM_FOR_TARGET`
11839     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11840 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11841   else
11842     # Canadian cross, just use what we found
11843     echo "$as_me:$LINENO: result: pre-installed" >&5
11844 echo "${ECHO_T}pre-installed" >&6
11845   fi
11846 else
11847   ok=yes
11848   case " ${configdirs} " in
11849     *" binutils "*) ;;
11850     *) ok=no ;;
11851   esac
11852
11853   if test $ok = yes; then
11854     # An in-tree tool is available and we can use it
11855     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11856     echo "$as_me:$LINENO: result: just compiled" >&5
11857 echo "${ECHO_T}just compiled" >&6
11858   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11859     # We already found the complete path
11860     ac_dir=`dirname $NM_FOR_TARGET`
11861     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11862 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11863   elif test "x$target" = "x$host"; then
11864     # We can use an host tool
11865     NM_FOR_TARGET='$(NM)'
11866     echo "$as_me:$LINENO: result: host tool" >&5
11867 echo "${ECHO_T}host tool" >&6
11868   else
11869     # We need a cross tool
11870     echo "$as_me:$LINENO: result: pre-installed" >&5
11871 echo "${ECHO_T}pre-installed" >&6
11872   fi
11873 fi
11874
11875 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11876 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11877 if test "x${build}" != "x${host}" ; then
11878   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11879     # We already found the complete path
11880     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11881     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11882 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11883   else
11884     # Canadian cross, just use what we found
11885     echo "$as_me:$LINENO: result: pre-installed" >&5
11886 echo "${ECHO_T}pre-installed" >&6
11887   fi
11888 else
11889   ok=yes
11890   case " ${configdirs} " in
11891     *" binutils "*) ;;
11892     *) ok=no ;;
11893   esac
11894
11895   if test $ok = yes; then
11896     # An in-tree tool is available and we can use it
11897     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11898     echo "$as_me:$LINENO: result: just compiled" >&5
11899 echo "${ECHO_T}just compiled" >&6
11900   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11901     # We already found the complete path
11902     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11903     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11904 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11905   elif test "x$target" = "x$host"; then
11906     # We can use an host tool
11907     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11908     echo "$as_me:$LINENO: result: host tool" >&5
11909 echo "${ECHO_T}host tool" >&6
11910   else
11911     # We need a cross tool
11912     echo "$as_me:$LINENO: result: pre-installed" >&5
11913 echo "${ECHO_T}pre-installed" >&6
11914   fi
11915 fi
11916
11917 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11918 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11919 if test "x${build}" != "x${host}" ; then
11920   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11921     # We already found the complete path
11922     ac_dir=`dirname $RANLIB_FOR_TARGET`
11923     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11924 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11925   else
11926     # Canadian cross, just use what we found
11927     echo "$as_me:$LINENO: result: pre-installed" >&5
11928 echo "${ECHO_T}pre-installed" >&6
11929   fi
11930 else
11931   ok=yes
11932   case " ${configdirs} " in
11933     *" binutils "*) ;;
11934     *) ok=no ;;
11935   esac
11936
11937   if test $ok = yes; then
11938     # An in-tree tool is available and we can use it
11939     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11940     echo "$as_me:$LINENO: result: just compiled" >&5
11941 echo "${ECHO_T}just compiled" >&6
11942   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11943     # We already found the complete path
11944     ac_dir=`dirname $RANLIB_FOR_TARGET`
11945     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11946 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11947   elif test "x$target" = "x$host"; then
11948     # We can use an host tool
11949     RANLIB_FOR_TARGET='$(RANLIB)'
11950     echo "$as_me:$LINENO: result: host tool" >&5
11951 echo "${ECHO_T}host tool" >&6
11952   else
11953     # We need a cross tool
11954     echo "$as_me:$LINENO: result: pre-installed" >&5
11955 echo "${ECHO_T}pre-installed" >&6
11956   fi
11957 fi
11958
11959 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11960 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11961 if test "x${build}" != "x${host}" ; then
11962   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11963     # We already found the complete path
11964     ac_dir=`dirname $STRIP_FOR_TARGET`
11965     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11966 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11967   else
11968     # Canadian cross, just use what we found
11969     echo "$as_me:$LINENO: result: pre-installed" >&5
11970 echo "${ECHO_T}pre-installed" >&6
11971   fi
11972 else
11973   ok=yes
11974   case " ${configdirs} " in
11975     *" binutils "*) ;;
11976     *) ok=no ;;
11977   esac
11978
11979   if test $ok = yes; then
11980     # An in-tree tool is available and we can use it
11981     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11982     echo "$as_me:$LINENO: result: just compiled" >&5
11983 echo "${ECHO_T}just compiled" >&6
11984   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11985     # We already found the complete path
11986     ac_dir=`dirname $STRIP_FOR_TARGET`
11987     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11988 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11989   elif test "x$target" = "x$host"; then
11990     # We can use an host tool
11991     STRIP_FOR_TARGET='$(STRIP)'
11992     echo "$as_me:$LINENO: result: host tool" >&5
11993 echo "${ECHO_T}host tool" >&6
11994   else
11995     # We need a cross tool
11996     echo "$as_me:$LINENO: result: pre-installed" >&5
11997 echo "${ECHO_T}pre-installed" >&6
11998   fi
11999 fi
12000
12001 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12002 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12003 if test "x${build}" != "x${host}" ; then
12004   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12005     # We already found the complete path
12006     ac_dir=`dirname $WINDRES_FOR_TARGET`
12007     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12008 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12009   else
12010     # Canadian cross, just use what we found
12011     echo "$as_me:$LINENO: result: pre-installed" >&5
12012 echo "${ECHO_T}pre-installed" >&6
12013   fi
12014 else
12015   ok=yes
12016   case " ${configdirs} " in
12017     *" binutils "*) ;;
12018     *) ok=no ;;
12019   esac
12020
12021   if test $ok = yes; then
12022     # An in-tree tool is available and we can use it
12023     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12024     echo "$as_me:$LINENO: result: just compiled" >&5
12025 echo "${ECHO_T}just compiled" >&6
12026   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12027     # We already found the complete path
12028     ac_dir=`dirname $WINDRES_FOR_TARGET`
12029     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12030 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12031   elif test "x$target" = "x$host"; then
12032     # We can use an host tool
12033     WINDRES_FOR_TARGET='$(WINDRES)'
12034     echo "$as_me:$LINENO: result: host tool" >&5
12035 echo "${ECHO_T}host tool" >&6
12036   else
12037     # We need a cross tool
12038     echo "$as_me:$LINENO: result: pre-installed" >&5
12039 echo "${ECHO_T}pre-installed" >&6
12040   fi
12041 fi
12042
12043 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12044 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12045 if test "x${build}" != "x${host}" ; then
12046   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12047     # We already found the complete path
12048     ac_dir=`dirname $WINDMC_FOR_TARGET`
12049     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12050 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12051   else
12052     # Canadian cross, just use what we found
12053     echo "$as_me:$LINENO: result: pre-installed" >&5
12054 echo "${ECHO_T}pre-installed" >&6
12055   fi
12056 else
12057   ok=yes
12058   case " ${configdirs} " in
12059     *" binutils "*) ;;
12060     *) ok=no ;;
12061   esac
12062
12063   if test $ok = yes; then
12064     # An in-tree tool is available and we can use it
12065     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12066     echo "$as_me:$LINENO: result: just compiled" >&5
12067 echo "${ECHO_T}just compiled" >&6
12068   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12069     # We already found the complete path
12070     ac_dir=`dirname $WINDMC_FOR_TARGET`
12071     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12072 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12073   elif test "x$target" = "x$host"; then
12074     # We can use an host tool
12075     WINDMC_FOR_TARGET='$(WINDMC)'
12076     echo "$as_me:$LINENO: result: host tool" >&5
12077 echo "${ECHO_T}host tool" >&6
12078   else
12079     # We need a cross tool
12080     echo "$as_me:$LINENO: result: pre-installed" >&5
12081 echo "${ECHO_T}pre-installed" >&6
12082   fi
12083 fi
12084
12085
12086
12087
12088
12089 # Certain tools may need extra flags.
12090 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12091 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12092 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12093
12094 # When building target libraries, except in a Canadian cross, we use
12095 # the same toolchain as the compiler we just built.
12096 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12097 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12098 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12099 if test $host = $build; then
12100   case " $configdirs " in
12101     *" gcc "*)
12102       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12103       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12104       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12105       ;;
12106   esac
12107 fi
12108
12109
12110
12111
12112
12113 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12114 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12115 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12116 if test "${enable_maintainer_mode+set}" = set; then
12117   enableval="$enable_maintainer_mode"
12118   USE_MAINTAINER_MODE=$enableval
12119 else
12120   USE_MAINTAINER_MODE=no
12121 fi;
12122 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12123 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12124
12125
12126 if test "$USE_MAINTAINER_MODE" = yes; then
12127   MAINTAINER_MODE_TRUE=
12128   MAINTAINER_MODE_FALSE='#'
12129 else
12130   MAINTAINER_MODE_TRUE='#'
12131   MAINTAINER_MODE_FALSE=
12132 fi
12133 MAINT=$MAINTAINER_MODE_TRUE
12134
12135 # ---------------------
12136 # GCC bootstrap support
12137 # ---------------------
12138
12139 # Stage specific cflags for build.
12140 stage1_cflags="-g"
12141 case $build in
12142   vax-*-*)
12143     case ${GCC} in
12144       yes) stage1_cflags="-g -Wa,-J" ;;
12145       *) stage1_cflags="-g -J" ;;
12146     esac ;;
12147 esac
12148
12149 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12150 if test "$GCC" = yes; then
12151   saved_CFLAGS="$CFLAGS"
12152
12153   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12154   CFLAGS="$CFLAGS -fkeep-inline-functions"
12155   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12156 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12157   cat >conftest.$ac_ext <<_ACEOF
12158 /* confdefs.h.  */
12159 _ACEOF
12160 cat confdefs.h >>conftest.$ac_ext
12161 cat >>conftest.$ac_ext <<_ACEOF
12162 /* end confdefs.h.  */
12163
12164 #if (__GNUC__ < 3) \
12165     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12166                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12167 #error http://gcc.gnu.org/PR29382
12168 #endif
12169
12170 int
12171 main ()
12172 {
12173
12174   ;
12175   return 0;
12176 }
12177 _ACEOF
12178 rm -f conftest.$ac_objext
12179 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12180   (eval $ac_compile) 2>conftest.er1
12181   ac_status=$?
12182   grep -v '^ *+' conftest.er1 >conftest.err
12183   rm -f conftest.er1
12184   cat conftest.err >&5
12185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12186   (exit $ac_status); } &&
12187          { ac_try='test -z "$ac_c_werror_flag"
12188                          || test ! -s conftest.err'
12189   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12190   (eval $ac_try) 2>&5
12191   ac_status=$?
12192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12193   (exit $ac_status); }; } &&
12194          { ac_try='test -s conftest.$ac_objext'
12195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12196   (eval $ac_try) 2>&5
12197   ac_status=$?
12198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12199   (exit $ac_status); }; }; then
12200   echo "$as_me:$LINENO: result: yes" >&5
12201 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12202 else
12203   echo "$as_me: failed program was:" >&5
12204 sed 's/^/| /' conftest.$ac_ext >&5
12205
12206 echo "$as_me:$LINENO: result: no" >&5
12207 echo "${ECHO_T}no" >&6
12208 fi
12209 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12210
12211   CFLAGS="$saved_CFLAGS"
12212 fi
12213
12214
12215
12216 # Enable --enable-checking in stage1 of the compiler.
12217 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12218 if test "${enable_stage1_checking+set}" = set; then
12219   enableval="$enable_stage1_checking"
12220   stage1_checking=--enable-checking=${enable_stage1_checking}
12221 else
12222   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12223   stage1_checking=--enable-checking=yes,types
12224 else
12225   stage1_checking=--enable-checking=$enable_checking,types
12226 fi
12227 fi;
12228
12229
12230 # Enable -Werror in bootstrap stage2 and later.
12231 # Check whether --enable-werror or --disable-werror was given.
12232 if test "${enable_werror+set}" = set; then
12233   enableval="$enable_werror"
12234
12235 else
12236   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12237   enable_werror=yes
12238 else
12239   enable_werror=no
12240 fi
12241 fi;
12242 case ${enable_werror} in
12243   yes) stage2_werror_flag="--enable-werror-always" ;;
12244   *) stage2_werror_flag="" ;;
12245 esac
12246
12247
12248 # Flags needed to enable html installing and building
12249
12250 # Check whether --with-datarootdir or --without-datarootdir was given.
12251 if test "${with_datarootdir+set}" = set; then
12252   withval="$with_datarootdir"
12253   datarootdir="\${prefix}/${withval}"
12254 else
12255   datarootdir="\${prefix}/share"
12256 fi;
12257
12258
12259 # Check whether --with-docdir or --without-docdir was given.
12260 if test "${with_docdir+set}" = set; then
12261   withval="$with_docdir"
12262   docdir="\${prefix}/${withval}"
12263 else
12264   docdir="\${datarootdir}/doc"
12265 fi;
12266
12267
12268 # Check whether --with-pdfdir or --without-pdfdir was given.
12269 if test "${with_pdfdir+set}" = set; then
12270   withval="$with_pdfdir"
12271   pdfdir="\${prefix}/${withval}"
12272 else
12273   pdfdir="\${docdir}"
12274 fi;
12275
12276
12277 # Check whether --with-htmldir or --without-htmldir was given.
12278 if test "${with_htmldir+set}" = set; then
12279   withval="$with_htmldir"
12280   htmldir="\${prefix}/${withval}"
12281 else
12282   htmldir="\${docdir}"
12283 fi;
12284
12285
12286
12287
12288
12289
12290           ac_config_files="$ac_config_files Makefile"
12291 cat >confcache <<\_ACEOF
12292 # This file is a shell script that caches the results of configure
12293 # tests run on this system so they can be shared between configure
12294 # scripts and configure runs, see configure's option --config-cache.
12295 # It is not useful on other systems.  If it contains results you don't
12296 # want to keep, you may remove or edit it.
12297 #
12298 # config.status only pays attention to the cache file if you give it
12299 # the --recheck option to rerun configure.
12300 #
12301 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12302 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12303 # following values.
12304
12305 _ACEOF
12306
12307 # The following way of writing the cache mishandles newlines in values,
12308 # but we know of no workaround that is simple, portable, and efficient.
12309 # So, don't put newlines in cache variables' values.
12310 # Ultrix sh set writes to stderr and can't be redirected directly,
12311 # and sets the high bit in the cache file unless we assign to the vars.
12312 {
12313   (set) 2>&1 |
12314     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12315     *ac_space=\ *)
12316       # `set' does not quote correctly, so add quotes (double-quote
12317       # substitution turns \\\\ into \\, and sed turns \\ into \).
12318       sed -n \
12319         "s/'/'\\\\''/g;
12320           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12321       ;;
12322     *)
12323       # `set' quotes correctly as required by POSIX, so do not add quotes.
12324       sed -n \
12325         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12326       ;;
12327     esac;
12328 } |
12329   sed '
12330      t clear
12331      : clear
12332      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12333      t end
12334      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12335      : end' >>confcache
12336 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12337   if test -w $cache_file; then
12338     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12339     cat confcache >$cache_file
12340   else
12341     echo "not updating unwritable cache $cache_file"
12342   fi
12343 fi
12344 rm -f confcache
12345
12346 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12347 # Let make expand exec_prefix.
12348 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12349
12350 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12351 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12352 # trailing colons and then remove the whole line if VPATH becomes empty
12353 # (actually we leave an empty line to preserve line numbers).
12354 if test "x$srcdir" = x.; then
12355   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12356 s/:*\$(srcdir):*/:/;
12357 s/:*\${srcdir}:*/:/;
12358 s/:*@srcdir@:*/:/;
12359 s/^\([^=]*=[     ]*\):*/\1/;
12360 s/:*$//;
12361 s/^[^=]*=[       ]*$//;
12362 }'
12363 fi
12364
12365 # Transform confdefs.h into DEFS.
12366 # Protect against shell expansion while executing Makefile rules.
12367 # Protect against Makefile macro expansion.
12368 #
12369 # If the first sed substitution is executed (which looks for macros that
12370 # take arguments), then we branch to the quote section.  Otherwise,
12371 # look for a macro that doesn't take arguments.
12372 cat >confdef2opt.sed <<\_ACEOF
12373 t clear
12374 : clear
12375 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12376 t quote
12377 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12378 t quote
12379 d
12380 : quote
12381 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12382 s,\[,\\&,g
12383 s,\],\\&,g
12384 s,\$,$$,g
12385 p
12386 _ACEOF
12387 # We use echo to avoid assuming a particular line-breaking character.
12388 # The extra dot is to prevent the shell from consuming trailing
12389 # line-breaks from the sub-command output.  A line-break within
12390 # single-quotes doesn't work because, if this script is created in a
12391 # platform that uses two characters for line-breaks (e.g., DOS), tr
12392 # would break.
12393 ac_LF_and_DOT=`echo; echo .`
12394 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12395 rm -f confdef2opt.sed
12396
12397
12398 ac_libobjs=
12399 ac_ltlibobjs=
12400 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12401   # 1. Remove the extension, and $U if already installed.
12402   ac_i=`echo "$ac_i" |
12403          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12404   # 2. Add them.
12405   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12406   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12407 done
12408 LIBOBJS=$ac_libobjs
12409
12410 LTLIBOBJS=$ac_ltlibobjs
12411
12412
12413
12414 : ${CONFIG_STATUS=./config.status}
12415 ac_clean_files_save=$ac_clean_files
12416 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12417 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12418 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12419 cat >$CONFIG_STATUS <<_ACEOF
12420 #! $SHELL
12421 # Generated by $as_me.
12422 # Run this file to recreate the current configuration.
12423 # Compiler output produced by configure, useful for debugging
12424 # configure, is in config.log if it exists.
12425
12426 debug=false
12427 ac_cs_recheck=false
12428 ac_cs_silent=false
12429 SHELL=\${CONFIG_SHELL-$SHELL}
12430 _ACEOF
12431
12432 cat >>$CONFIG_STATUS <<\_ACEOF
12433 ## --------------------- ##
12434 ## M4sh Initialization.  ##
12435 ## --------------------- ##
12436
12437 # Be Bourne compatible
12438 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12439   emulate sh
12440   NULLCMD=:
12441   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12442   # is contrary to our usage.  Disable this feature.
12443   alias -g '${1+"$@"}'='"$@"'
12444 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12445   set -o posix
12446 fi
12447 DUALCASE=1; export DUALCASE # for MKS sh
12448
12449 # Support unset when possible.
12450 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12451   as_unset=unset
12452 else
12453   as_unset=false
12454 fi
12455
12456
12457 # Work around bugs in pre-3.0 UWIN ksh.
12458 $as_unset ENV MAIL MAILPATH
12459 PS1='$ '
12460 PS2='> '
12461 PS4='+ '
12462
12463 # NLS nuisances.
12464 for as_var in \
12465   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12466   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12467   LC_TELEPHONE LC_TIME
12468 do
12469   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12470     eval $as_var=C; export $as_var
12471   else
12472     $as_unset $as_var
12473   fi
12474 done
12475
12476 # Required to use basename.
12477 if expr a : '\(a\)' >/dev/null 2>&1; then
12478   as_expr=expr
12479 else
12480   as_expr=false
12481 fi
12482
12483 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12484   as_basename=basename
12485 else
12486   as_basename=false
12487 fi
12488
12489
12490 # Name of the executable.
12491 as_me=`$as_basename "$0" ||
12492 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12493          X"$0" : 'X\(//\)$' \| \
12494          X"$0" : 'X\(/\)$' \| \
12495          .     : '\(.\)' 2>/dev/null ||
12496 echo X/"$0" |
12497     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12498           /^X\/\(\/\/\)$/{ s//\1/; q; }
12499           /^X\/\(\/\).*/{ s//\1/; q; }
12500           s/.*/./; q'`
12501
12502
12503 # PATH needs CR, and LINENO needs CR and PATH.
12504 # Avoid depending upon Character Ranges.
12505 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12506 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12507 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12508 as_cr_digits='0123456789'
12509 as_cr_alnum=$as_cr_Letters$as_cr_digits
12510
12511 # The user is always right.
12512 if test "${PATH_SEPARATOR+set}" != set; then
12513   echo "#! /bin/sh" >conf$$.sh
12514   echo  "exit 0"   >>conf$$.sh
12515   chmod +x conf$$.sh
12516   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12517     PATH_SEPARATOR=';'
12518   else
12519     PATH_SEPARATOR=:
12520   fi
12521   rm -f conf$$.sh
12522 fi
12523
12524
12525   as_lineno_1=$LINENO
12526   as_lineno_2=$LINENO
12527   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12528   test "x$as_lineno_1" != "x$as_lineno_2" &&
12529   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12530   # Find who we are.  Look in the path if we contain no path at all
12531   # relative or not.
12532   case $0 in
12533     *[\\/]* ) as_myself=$0 ;;
12534     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12535 for as_dir in $PATH
12536 do
12537   IFS=$as_save_IFS
12538   test -z "$as_dir" && as_dir=.
12539   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12540 done
12541
12542        ;;
12543   esac
12544   # We did not find ourselves, most probably we were run as `sh COMMAND'
12545   # in which case we are not to be found in the path.
12546   if test "x$as_myself" = x; then
12547     as_myself=$0
12548   fi
12549   if test ! -f "$as_myself"; then
12550     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12551 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12552    { (exit 1); exit 1; }; }
12553   fi
12554   case $CONFIG_SHELL in
12555   '')
12556     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12557 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12558 do
12559   IFS=$as_save_IFS
12560   test -z "$as_dir" && as_dir=.
12561   for as_base in sh bash ksh sh5; do
12562          case $as_dir in
12563          /*)
12564            if ("$as_dir/$as_base" -c '
12565   as_lineno_1=$LINENO
12566   as_lineno_2=$LINENO
12567   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12568   test "x$as_lineno_1" != "x$as_lineno_2" &&
12569   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12570              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12571              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12572              CONFIG_SHELL=$as_dir/$as_base
12573              export CONFIG_SHELL
12574              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12575            fi;;
12576          esac
12577        done
12578 done
12579 ;;
12580   esac
12581
12582   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12583   # uniformly replaced by the line number.  The first 'sed' inserts a
12584   # line-number line before each line; the second 'sed' does the real
12585   # work.  The second script uses 'N' to pair each line-number line
12586   # with the numbered line, and appends trailing '-' during
12587   # substitution so that $LINENO is not a special case at line end.
12588   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12589   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12590   sed '=' <$as_myself |
12591     sed '
12592       N
12593       s,$,-,
12594       : loop
12595       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12596       t loop
12597       s,-$,,
12598       s,^['$as_cr_digits']*\n,,
12599     ' >$as_me.lineno &&
12600   chmod +x $as_me.lineno ||
12601     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12602 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12603    { (exit 1); exit 1; }; }
12604
12605   # Don't try to exec as it changes $[0], causing all sort of problems
12606   # (the dirname of $[0] is not the place where we might find the
12607   # original and so on.  Autoconf is especially sensible to this).
12608   . ./$as_me.lineno
12609   # Exit status is that of the last command.
12610   exit
12611 }
12612
12613
12614 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12615   *c*,-n*) ECHO_N= ECHO_C='
12616 ' ECHO_T='      ' ;;
12617   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12618   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12619 esac
12620
12621 if expr a : '\(a\)' >/dev/null 2>&1; then
12622   as_expr=expr
12623 else
12624   as_expr=false
12625 fi
12626
12627 rm -f conf$$ conf$$.exe conf$$.file
12628 echo >conf$$.file
12629 if ln -s conf$$.file conf$$ 2>/dev/null; then
12630   # We could just check for DJGPP; but this test a) works b) is more generic
12631   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12632   if test -f conf$$.exe; then
12633     # Don't use ln at all; we don't have any links
12634     as_ln_s='cp -p'
12635   else
12636     as_ln_s='ln -s'
12637   fi
12638 elif ln conf$$.file conf$$ 2>/dev/null; then
12639   as_ln_s=ln
12640 else
12641   as_ln_s='cp -p'
12642 fi
12643 rm -f conf$$ conf$$.exe conf$$.file
12644
12645 if mkdir -p . 2>/dev/null; then
12646   as_mkdir_p=:
12647 else
12648   test -d ./-p && rmdir ./-p
12649   as_mkdir_p=false
12650 fi
12651
12652 as_executable_p="test -f"
12653
12654 # Sed expression to map a string onto a valid CPP name.
12655 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12656
12657 # Sed expression to map a string onto a valid variable name.
12658 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12659
12660
12661 # IFS
12662 # We need space, tab and new line, in precisely that order.
12663 as_nl='
12664 '
12665 IFS="   $as_nl"
12666
12667 # CDPATH.
12668 $as_unset CDPATH
12669
12670 exec 6>&1
12671
12672 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12673 # report actual input values of CONFIG_FILES etc. instead of their
12674 # values after options handling.  Logging --version etc. is OK.
12675 exec 5>>config.log
12676 {
12677   echo
12678   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12679 ## Running $as_me. ##
12680 _ASBOX
12681 } >&5
12682 cat >&5 <<_CSEOF
12683
12684 This file was extended by $as_me, which was
12685 generated by GNU Autoconf 2.59.  Invocation command line was
12686
12687   CONFIG_FILES    = $CONFIG_FILES
12688   CONFIG_HEADERS  = $CONFIG_HEADERS
12689   CONFIG_LINKS    = $CONFIG_LINKS
12690   CONFIG_COMMANDS = $CONFIG_COMMANDS
12691   $ $0 $@
12692
12693 _CSEOF
12694 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12695 echo >&5
12696 _ACEOF
12697
12698 # Files that config.status was made for.
12699 if test -n "$ac_config_files"; then
12700   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12701 fi
12702
12703 if test -n "$ac_config_headers"; then
12704   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12705 fi
12706
12707 if test -n "$ac_config_links"; then
12708   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12709 fi
12710
12711 if test -n "$ac_config_commands"; then
12712   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12713 fi
12714
12715 cat >>$CONFIG_STATUS <<\_ACEOF
12716
12717 ac_cs_usage="\
12718 \`$as_me' instantiates files from templates according to the
12719 current configuration.
12720
12721 Usage: $0 [OPTIONS] [FILE]...
12722
12723   -h, --help       print this help, then exit
12724   -V, --version    print version number, then exit
12725   -q, --quiet      do not print progress messages
12726   -d, --debug      don't remove temporary files
12727       --recheck    update $as_me by reconfiguring in the same conditions
12728   --file=FILE[:TEMPLATE]
12729                    instantiate the configuration file FILE
12730
12731 Configuration files:
12732 $config_files
12733
12734 Report bugs to <bug-autoconf@gnu.org>."
12735 _ACEOF
12736
12737 cat >>$CONFIG_STATUS <<_ACEOF
12738 ac_cs_version="\\
12739 config.status
12740 configured by $0, generated by GNU Autoconf 2.59,
12741   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12742
12743 Copyright (C) 2003 Free Software Foundation, Inc.
12744 This config.status script is free software; the Free Software Foundation
12745 gives unlimited permission to copy, distribute and modify it."
12746 srcdir=$srcdir
12747 INSTALL="$INSTALL"
12748 _ACEOF
12749
12750 cat >>$CONFIG_STATUS <<\_ACEOF
12751 # If no file are specified by the user, then we need to provide default
12752 # value.  By we need to know if files were specified by the user.
12753 ac_need_defaults=:
12754 while test $# != 0
12755 do
12756   case $1 in
12757   --*=*)
12758     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12759     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12760     ac_shift=:
12761     ;;
12762   -*)
12763     ac_option=$1
12764     ac_optarg=$2
12765     ac_shift=shift
12766     ;;
12767   *) # This is not an option, so the user has probably given explicit
12768      # arguments.
12769      ac_option=$1
12770      ac_need_defaults=false;;
12771   esac
12772
12773   case $ac_option in
12774   # Handling of the options.
12775 _ACEOF
12776 cat >>$CONFIG_STATUS <<\_ACEOF
12777   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12778     ac_cs_recheck=: ;;
12779   --version | --vers* | -V )
12780     echo "$ac_cs_version"; exit 0 ;;
12781   --he | --h)
12782     # Conflict between --help and --header
12783     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12784 Try \`$0 --help' for more information." >&5
12785 echo "$as_me: error: ambiguous option: $1
12786 Try \`$0 --help' for more information." >&2;}
12787    { (exit 1); exit 1; }; };;
12788   --help | --hel | -h )
12789     echo "$ac_cs_usage"; exit 0 ;;
12790   --debug | --d* | -d )
12791     debug=: ;;
12792   --file | --fil | --fi | --f )
12793     $ac_shift
12794     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12795     ac_need_defaults=false;;
12796   --header | --heade | --head | --hea )
12797     $ac_shift
12798     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12799     ac_need_defaults=false;;
12800   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12801   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12802     ac_cs_silent=: ;;
12803
12804   # This is an error.
12805   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12806 Try \`$0 --help' for more information." >&5
12807 echo "$as_me: error: unrecognized option: $1
12808 Try \`$0 --help' for more information." >&2;}
12809    { (exit 1); exit 1; }; } ;;
12810
12811   *) ac_config_targets="$ac_config_targets $1" ;;
12812
12813   esac
12814   shift
12815 done
12816
12817 ac_configure_extra_args=
12818
12819 if $ac_cs_silent; then
12820   exec 6>/dev/null
12821   ac_configure_extra_args="$ac_configure_extra_args --silent"
12822 fi
12823
12824 _ACEOF
12825 cat >>$CONFIG_STATUS <<_ACEOF
12826 if \$ac_cs_recheck; then
12827   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12828   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12829 fi
12830
12831 _ACEOF
12832
12833
12834
12835
12836
12837 cat >>$CONFIG_STATUS <<\_ACEOF
12838 for ac_config_target in $ac_config_targets
12839 do
12840   case "$ac_config_target" in
12841   # Handling of arguments.
12842   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12843   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12844 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12845    { (exit 1); exit 1; }; };;
12846   esac
12847 done
12848
12849 # If the user did not use the arguments to specify the items to instantiate,
12850 # then the envvar interface is used.  Set only those that are not.
12851 # We use the long form for the default assignment because of an extremely
12852 # bizarre bug on SunOS 4.1.3.
12853 if $ac_need_defaults; then
12854   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12855 fi
12856
12857 # Have a temporary directory for convenience.  Make it in the build tree
12858 # simply because there is no reason to put it here, and in addition,
12859 # creating and moving files from /tmp can sometimes cause problems.
12860 # Create a temporary directory, and hook for its removal unless debugging.
12861 $debug ||
12862 {
12863   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12864   trap '{ (exit 1); exit 1; }' 1 2 13 15
12865 }
12866
12867 # Create a (secure) tmp directory for tmp files.
12868
12869 {
12870   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12871   test -n "$tmp" && test -d "$tmp"
12872 }  ||
12873 {
12874   tmp=./confstat$$-$RANDOM
12875   (umask 077 && mkdir $tmp)
12876 } ||
12877 {
12878    echo "$me: cannot create a temporary directory in ." >&2
12879    { (exit 1); exit 1; }
12880 }
12881
12882 _ACEOF
12883
12884 cat >>$CONFIG_STATUS <<_ACEOF
12885
12886 #
12887 # CONFIG_FILES section.
12888 #
12889
12890 # No need to generate the scripts if there are no CONFIG_FILES.
12891 # This happens for instance when ./config.status config.h
12892 if test -n "\$CONFIG_FILES"; then
12893   # Protect against being on the right side of a sed subst in config.status.
12894   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12895    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12896 s,@SHELL@,$SHELL,;t t
12897 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12898 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12899 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12900 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12901 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12902 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12903 s,@exec_prefix@,$exec_prefix,;t t
12904 s,@prefix@,$prefix,;t t
12905 s,@program_transform_name@,$program_transform_name,;t t
12906 s,@bindir@,$bindir,;t t
12907 s,@sbindir@,$sbindir,;t t
12908 s,@libexecdir@,$libexecdir,;t t
12909 s,@datadir@,$datadir,;t t
12910 s,@sysconfdir@,$sysconfdir,;t t
12911 s,@sharedstatedir@,$sharedstatedir,;t t
12912 s,@localstatedir@,$localstatedir,;t t
12913 s,@libdir@,$libdir,;t t
12914 s,@includedir@,$includedir,;t t
12915 s,@oldincludedir@,$oldincludedir,;t t
12916 s,@infodir@,$infodir,;t t
12917 s,@mandir@,$mandir,;t t
12918 s,@build_alias@,$build_alias,;t t
12919 s,@host_alias@,$host_alias,;t t
12920 s,@target_alias@,$target_alias,;t t
12921 s,@DEFS@,$DEFS,;t t
12922 s,@ECHO_C@,$ECHO_C,;t t
12923 s,@ECHO_N@,$ECHO_N,;t t
12924 s,@ECHO_T@,$ECHO_T,;t t
12925 s,@LIBS@,$LIBS,;t t
12926 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12927 s,@build@,$build,;t t
12928 s,@build_cpu@,$build_cpu,;t t
12929 s,@build_vendor@,$build_vendor,;t t
12930 s,@build_os@,$build_os,;t t
12931 s,@build_noncanonical@,$build_noncanonical,;t t
12932 s,@host_noncanonical@,$host_noncanonical,;t t
12933 s,@target_noncanonical@,$target_noncanonical,;t t
12934 s,@host@,$host,;t t
12935 s,@host_cpu@,$host_cpu,;t t
12936 s,@host_vendor@,$host_vendor,;t t
12937 s,@host_os@,$host_os,;t t
12938 s,@target@,$target,;t t
12939 s,@target_cpu@,$target_cpu,;t t
12940 s,@target_vendor@,$target_vendor,;t t
12941 s,@target_os@,$target_os,;t t
12942 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12943 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12944 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12945 s,@LN@,$LN,;t t
12946 s,@LN_S@,$LN_S,;t t
12947 s,@build_libsubdir@,$build_libsubdir,;t t
12948 s,@build_subdir@,$build_subdir,;t t
12949 s,@host_subdir@,$host_subdir,;t t
12950 s,@target_subdir@,$target_subdir,;t t
12951 s,@CC@,$CC,;t t
12952 s,@CFLAGS@,$CFLAGS,;t t
12953 s,@LDFLAGS@,$LDFLAGS,;t t
12954 s,@CPPFLAGS@,$CPPFLAGS,;t t
12955 s,@ac_ct_CC@,$ac_ct_CC,;t t
12956 s,@EXEEXT@,$EXEEXT,;t t
12957 s,@OBJEXT@,$OBJEXT,;t t
12958 s,@CXX@,$CXX,;t t
12959 s,@CXXFLAGS@,$CXXFLAGS,;t t
12960 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12961 s,@GNATBIND@,$GNATBIND,;t t
12962 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12963 s,@GNATMAKE@,$GNATMAKE,;t t
12964 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12965 s,@do_compare@,$do_compare,;t t
12966 s,@gmplibs@,$gmplibs,;t t
12967 s,@gmpinc@,$gmpinc,;t t
12968 s,@stage1_languages@,$stage1_languages,;t t
12969 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12970 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12971 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12972 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12973 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12974 s,@tooldir@,$tooldir,;t t
12975 s,@build_tooldir@,$build_tooldir,;t t
12976 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12977 s,@GDB_TK@,$GDB_TK,;t t
12978 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12979 s,@build_configargs@,$build_configargs,;t t
12980 s,@build_configdirs@,$build_configdirs,;t t
12981 s,@host_configargs@,$host_configargs,;t t
12982 s,@configdirs@,$configdirs,;t t
12983 s,@target_configargs@,$target_configargs,;t t
12984 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12985 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12986 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12987 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12988 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12989 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12990 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12991 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12992 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12993 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12994 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12995 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12996 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12997 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12998 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12999 s,@config_shell@,$config_shell,;t t
13000 s,@YACC@,$YACC,;t t
13001 s,@BISON@,$BISON,;t t
13002 s,@M4@,$M4,;t t
13003 s,@LEX@,$LEX,;t t
13004 s,@FLEX@,$FLEX,;t t
13005 s,@MAKEINFO@,$MAKEINFO,;t t
13006 s,@EXPECT@,$EXPECT,;t t
13007 s,@RUNTEST@,$RUNTEST,;t t
13008 s,@AR@,$AR,;t t
13009 s,@AS@,$AS,;t t
13010 s,@DLLTOOL@,$DLLTOOL,;t t
13011 s,@LD@,$LD,;t t
13012 s,@LIPO@,$LIPO,;t t
13013 s,@NM@,$NM,;t t
13014 s,@RANLIB@,$RANLIB,;t t
13015 s,@STRIP@,$STRIP,;t t
13016 s,@WINDRES@,$WINDRES,;t t
13017 s,@WINDMC@,$WINDMC,;t t
13018 s,@OBJCOPY@,$OBJCOPY,;t t
13019 s,@OBJDUMP@,$OBJDUMP,;t t
13020 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13021 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13022 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13023 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13024 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13025 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13026 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13027 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13028 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13029 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13030 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13031 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13032 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13033 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13034 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13035 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13036 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13037 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13038 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13039 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13040 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13041 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13042 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13043 s,@MAINT@,$MAINT,;t t
13044 s,@stage1_cflags@,$stage1_cflags,;t t
13045 s,@stage1_checking@,$stage1_checking,;t t
13046 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13047 s,@datarootdir@,$datarootdir,;t t
13048 s,@docdir@,$docdir,;t t
13049 s,@pdfdir@,$pdfdir,;t t
13050 s,@htmldir@,$htmldir,;t t
13051 s,@LIBOBJS@,$LIBOBJS,;t t
13052 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13053 /@serialization_dependencies@/r $serialization_dependencies
13054 s,@serialization_dependencies@,,;t t
13055 /@host_makefile_frag@/r $host_makefile_frag
13056 s,@host_makefile_frag@,,;t t
13057 /@target_makefile_frag@/r $target_makefile_frag
13058 s,@target_makefile_frag@,,;t t
13059 /@alphaieee_frag@/r $alphaieee_frag
13060 s,@alphaieee_frag@,,;t t
13061 /@ospace_frag@/r $ospace_frag
13062 s,@ospace_frag@,,;t t
13063 CEOF
13064
13065 _ACEOF
13066
13067   cat >>$CONFIG_STATUS <<\_ACEOF
13068   # Split the substitutions into bite-sized pieces for seds with
13069   # small command number limits, like on Digital OSF/1 and HP-UX.
13070   ac_max_sed_lines=48
13071   ac_sed_frag=1 # Number of current file.
13072   ac_beg=1 # First line for current file.
13073   ac_end=$ac_max_sed_lines # Line after last line for current file.
13074   ac_more_lines=:
13075   ac_sed_cmds=
13076   while $ac_more_lines; do
13077     if test $ac_beg -gt 1; then
13078       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13079     else
13080       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13081     fi
13082     if test ! -s $tmp/subs.frag; then
13083       ac_more_lines=false
13084     else
13085       # The purpose of the label and of the branching condition is to
13086       # speed up the sed processing (if there are no `@' at all, there
13087       # is no need to browse any of the substitutions).
13088       # These are the two extra sed commands mentioned above.
13089       (echo ':t
13090   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13091       if test -z "$ac_sed_cmds"; then
13092         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13093       else
13094         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13095       fi
13096       ac_sed_frag=`expr $ac_sed_frag + 1`
13097       ac_beg=$ac_end
13098       ac_end=`expr $ac_end + $ac_max_sed_lines`
13099     fi
13100   done
13101   if test -z "$ac_sed_cmds"; then
13102     ac_sed_cmds=cat
13103   fi
13104 fi # test -n "$CONFIG_FILES"
13105
13106 _ACEOF
13107 cat >>$CONFIG_STATUS <<\_ACEOF
13108 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13109   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13110   case $ac_file in
13111   - | *:- | *:-:* ) # input from stdin
13112         cat >$tmp/stdin
13113         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13114         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13115   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13116         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13117   * )   ac_file_in=$ac_file.in ;;
13118   esac
13119
13120   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13121   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13122 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13123          X"$ac_file" : 'X\(//\)[^/]' \| \
13124          X"$ac_file" : 'X\(//\)$' \| \
13125          X"$ac_file" : 'X\(/\)' \| \
13126          .     : '\(.\)' 2>/dev/null ||
13127 echo X"$ac_file" |
13128     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13129           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13130           /^X\(\/\/\)$/{ s//\1/; q; }
13131           /^X\(\/\).*/{ s//\1/; q; }
13132           s/.*/./; q'`
13133   { if $as_mkdir_p; then
13134     mkdir -p "$ac_dir"
13135   else
13136     as_dir="$ac_dir"
13137     as_dirs=
13138     while test ! -d "$as_dir"; do
13139       as_dirs="$as_dir $as_dirs"
13140       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13141 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13142          X"$as_dir" : 'X\(//\)[^/]' \| \
13143          X"$as_dir" : 'X\(//\)$' \| \
13144          X"$as_dir" : 'X\(/\)' \| \
13145          .     : '\(.\)' 2>/dev/null ||
13146 echo X"$as_dir" |
13147     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13148           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13149           /^X\(\/\/\)$/{ s//\1/; q; }
13150           /^X\(\/\).*/{ s//\1/; q; }
13151           s/.*/./; q'`
13152     done
13153     test ! -n "$as_dirs" || mkdir $as_dirs
13154   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13155 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13156    { (exit 1); exit 1; }; }; }
13157
13158   ac_builddir=.
13159
13160 if test "$ac_dir" != .; then
13161   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13162   # A "../" for each directory in $ac_dir_suffix.
13163   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13164 else
13165   ac_dir_suffix= ac_top_builddir=
13166 fi
13167
13168 case $srcdir in
13169   .)  # No --srcdir option.  We are building in place.
13170     ac_srcdir=.
13171     if test -z "$ac_top_builddir"; then
13172        ac_top_srcdir=.
13173     else
13174        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13175     fi ;;
13176   [\\/]* | ?:[\\/]* )  # Absolute path.
13177     ac_srcdir=$srcdir$ac_dir_suffix;
13178     ac_top_srcdir=$srcdir ;;
13179   *) # Relative path.
13180     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13181     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13182 esac
13183
13184 # Do not use `cd foo && pwd` to compute absolute paths, because
13185 # the directories may not exist.
13186 case `pwd` in
13187 .) ac_abs_builddir="$ac_dir";;
13188 *)
13189   case "$ac_dir" in
13190   .) ac_abs_builddir=`pwd`;;
13191   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13192   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13193   esac;;
13194 esac
13195 case $ac_abs_builddir in
13196 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13197 *)
13198   case ${ac_top_builddir}. in
13199   .) ac_abs_top_builddir=$ac_abs_builddir;;
13200   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13201   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13202   esac;;
13203 esac
13204 case $ac_abs_builddir in
13205 .) ac_abs_srcdir=$ac_srcdir;;
13206 *)
13207   case $ac_srcdir in
13208   .) ac_abs_srcdir=$ac_abs_builddir;;
13209   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13210   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13211   esac;;
13212 esac
13213 case $ac_abs_builddir in
13214 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13215 *)
13216   case $ac_top_srcdir in
13217   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13218   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13219   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13220   esac;;
13221 esac
13222
13223
13224   case $INSTALL in
13225   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13226   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13227   esac
13228
13229   if test x"$ac_file" != x-; then
13230     { echo "$as_me:$LINENO: creating $ac_file" >&5
13231 echo "$as_me: creating $ac_file" >&6;}
13232     rm -f "$ac_file"
13233   fi
13234   # Let's still pretend it is `configure' which instantiates (i.e., don't
13235   # use $as_me), people would be surprised to read:
13236   #    /* config.h.  Generated by config.status.  */
13237   if test x"$ac_file" = x-; then
13238     configure_input=
13239   else
13240     configure_input="$ac_file.  "
13241   fi
13242   configure_input=$configure_input"Generated from `echo $ac_file_in |
13243                                      sed 's,.*/,,'` by configure."
13244
13245   # First look for the input files in the build tree, otherwise in the
13246   # src tree.
13247   ac_file_inputs=`IFS=:
13248     for f in $ac_file_in; do
13249       case $f in
13250       -) echo $tmp/stdin ;;
13251       [\\/$]*)
13252          # Absolute (can't be DOS-style, as IFS=:)
13253          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13254 echo "$as_me: error: cannot find input file: $f" >&2;}
13255    { (exit 1); exit 1; }; }
13256          echo "$f";;
13257       *) # Relative
13258          if test -f "$f"; then
13259            # Build tree
13260            echo "$f"
13261          elif test -f "$srcdir/$f"; then
13262            # Source tree
13263            echo "$srcdir/$f"
13264          else
13265            # /dev/null tree
13266            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13267 echo "$as_me: error: cannot find input file: $f" >&2;}
13268    { (exit 1); exit 1; }; }
13269          fi;;
13270       esac
13271     done` || { (exit 1); exit 1; }
13272 _ACEOF
13273 cat >>$CONFIG_STATUS <<_ACEOF
13274   sed "$ac_vpsub
13275 $extrasub
13276 _ACEOF
13277 cat >>$CONFIG_STATUS <<\_ACEOF
13278 :t
13279 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13280 s,@configure_input@,$configure_input,;t t
13281 s,@srcdir@,$ac_srcdir,;t t
13282 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13283 s,@top_srcdir@,$ac_top_srcdir,;t t
13284 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13285 s,@builddir@,$ac_builddir,;t t
13286 s,@abs_builddir@,$ac_abs_builddir,;t t
13287 s,@top_builddir@,$ac_top_builddir,;t t
13288 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13289 s,@INSTALL@,$ac_INSTALL,;t t
13290 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13291   rm -f $tmp/stdin
13292   if test x"$ac_file" != x-; then
13293     mv $tmp/out $ac_file
13294   else
13295     cat $tmp/out
13296     rm -f $tmp/out
13297   fi
13298
13299 done
13300 _ACEOF
13301
13302 cat >>$CONFIG_STATUS <<\_ACEOF
13303
13304 { (exit 0); exit 0; }
13305 _ACEOF
13306 chmod +x $CONFIG_STATUS
13307 ac_clean_files=$ac_clean_files_save
13308
13309
13310 # configure is writing to config.log, and then calls config.status.
13311 # config.status does its own redirection, appending to config.log.
13312 # Unfortunately, on DOS this fails, as config.log is still kept open
13313 # by configure, so config.status won't be able to write to it; its
13314 # output is simply discarded.  So we exec the FD to /dev/null,
13315 # effectively closing config.log, so it can be properly (re)opened and
13316 # appended to by config.status.  When coming back to configure, we
13317 # need to make the FD available again.
13318 if test "$no_create" != yes; then
13319   ac_cs_success=:
13320   ac_config_status_args=
13321   test "$silent" = yes &&
13322     ac_config_status_args="$ac_config_status_args --quiet"
13323   exec 5>/dev/null
13324   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13325   exec 5>>config.log
13326   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13327   # would make configure fail if this is the last instruction.
13328   $ac_cs_success || { (exit 1); exit 1; }
13329 fi
13330