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 GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-stage1-languages[=all]   choose additional languages to build during
 939                           stage1.  Mostly useful for compiler development.
 940   --enable-objc-gc        enable use of Boehm's garbage collector with the
 941                           GNU Objective-C runtime
 942   --enable-bootstrap      enable bootstrapping [yes if native build]
 943   --enable-serial-[{host,target,build}-]configure
 944                           force sequential configuration of
 945                           sub-packages for the host, target or build
 946                           machine, or all sub-packages
 947   --enable-maintainer-mode enable make rules and dependencies not useful
 948                           (and sometimes confusing) to the casual installer
 949   --enable-stage1-checking[=all]   choose additional checking for stage1
 950                           of the compiler
 951   --enable-werror         enable -Werror in bootstrap stage2 and later
 952
 953 Optional Packages:
 954   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 955   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 956   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 957   --with-mpfr-dir=PATH    this option has been REMOVED
 958   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 959                           Equivalent to --with-mpfr-include=PATH/include
 960                           plus --with-mpfr-lib=PATH/lib
 961   --with-mpfr-include=PATH
 962                           specify directory for installed MPFR include files
 963   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 964   --with-gmp-dir=PATH     this option has been REMOVED
 965   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 966                           Equivalent to --with-gmp-include=PATH/include
 967                           plus --with-gmp-lib=PATH/lib
 968   --with-gmp-include=PATH specify directory for installed GMP include files
 969   --with-gmp-lib=PATH     specify directory for the installed GMP library
 970   --with-build-sysroot=SYSROOT
 971                           use sysroot as the system root during the build
 972   --with-debug-prefix-map='A=B C=D ...'
 973                              map A to B, C to D ... in debug information
 974   --with-build-time-tools=PATH
 975                           use given path to find target tools during the build
 976   --with-datarootdir      use datarootdir as the data root directory.
 977   --with-docdir           install documentation in this directory.
 978   --with-pdfdir           install pdf in this directory.
 979   --with-htmldir          install html in this directory.
 980
 981 Some influential environment variables:
 982   CC          C compiler command
 983   CFLAGS      C compiler flags
 984   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 985               nonstandard directory <lib dir>
 986   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 987               headers in a nonstandard directory <include dir>
 988   CXX         C++ compiler command
 989   CXXFLAGS    C++ compiler flags
 990   AR          AR for the host
 991   AS          AS for the host
 992   DLLTOOL     DLLTOOL for the host
 993   LD          LD for the host
 994   LIPO        LIPO for the host
 995   NM          NM for the host
 996   RANLIB      RANLIB for the host
 997   STRIP       STRIP for the host
 998   WINDRES     WINDRES for the host
 999   WINDMC      WINDMC for the host
1000   OBJCOPY     OBJCOPY for the host
1001   OBJDUMP     OBJDUMP for the host
1002   CC_FOR_TARGET
1003               CC for the target
1004   CXX_FOR_TARGET
1005               CXX for the target
1006   GCC_FOR_TARGET
1007               GCC for the target
1008   GCJ_FOR_TARGET
1009               GCJ for the target
1010   GFORTRAN_FOR_TARGET
1011               GFORTRAN for the target
1012   AR_FOR_TARGET
1013               AR for the target
1014   AS_FOR_TARGET
1015               AS for the target
1016   DLLTOOL_FOR_TARGET
1017               DLLTOOL for the target
1018   LD_FOR_TARGET
1019               LD for the target
1020   LIPO_FOR_TARGET
1021               LIPO for the target
1022   NM_FOR_TARGET
1023               NM for the target
1024   OBJDUMP_FOR_TARGET
1025               OBJDUMP for the target
1026   RANLIB_FOR_TARGET
1027               RANLIB for the target
1028   STRIP_FOR_TARGET
1029               STRIP for the target
1030   WINDRES_FOR_TARGET
1031               WINDRES for the target
1032   WINDMC_FOR_TARGET
1033               WINDMC for the target
1034
1035 Use these variables to override the choices made by `configure' or to help
1036 it to find libraries and programs with nonstandard names/locations.
1037
1038 _ACEOF
1039 fi
1040
1041 if test "$ac_init_help" = "recursive"; then
1042   # If there are subdirs, report their specific --help.
1043   ac_popdir=`pwd`
1044   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1045     test -d $ac_dir || continue
1046     ac_builddir=.
1047
1048 if test "$ac_dir" != .; then
1049   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1050   # A "../" for each directory in $ac_dir_suffix.
1051   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1052 else
1053   ac_dir_suffix= ac_top_builddir=
1054 fi
1055
1056 case $srcdir in
1057   .)  # No --srcdir option.  We are building in place.
1058     ac_srcdir=.
1059     if test -z "$ac_top_builddir"; then
1060        ac_top_srcdir=.
1061     else
1062        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1063     fi ;;
1064   [\\/]* | ?:[\\/]* )  # Absolute path.
1065     ac_srcdir=$srcdir$ac_dir_suffix;
1066     ac_top_srcdir=$srcdir ;;
1067   *) # Relative path.
1068     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1069     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1070 esac
1071
1072 # Do not use `cd foo && pwd` to compute absolute paths, because
1073 # the directories may not exist.
1074 case `pwd` in
1075 .) ac_abs_builddir="$ac_dir";;
1076 *)
1077   case "$ac_dir" in
1078   .) ac_abs_builddir=`pwd`;;
1079   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1080   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1081   esac;;
1082 esac
1083 case $ac_abs_builddir in
1084 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1085 *)
1086   case ${ac_top_builddir}. in
1087   .) ac_abs_top_builddir=$ac_abs_builddir;;
1088   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1089   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1090   esac;;
1091 esac
1092 case $ac_abs_builddir in
1093 .) ac_abs_srcdir=$ac_srcdir;;
1094 *)
1095   case $ac_srcdir in
1096   .) ac_abs_srcdir=$ac_abs_builddir;;
1097   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1098   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1099   esac;;
1100 esac
1101 case $ac_abs_builddir in
1102 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1103 *)
1104   case $ac_top_srcdir in
1105   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1106   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1107   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1108   esac;;
1109 esac
1110
1111     cd $ac_dir
1112     # Check for guested configure; otherwise get Cygnus style configure.
1113     if test -f $ac_srcdir/configure.gnu; then
1114       echo
1115       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1116     elif test -f $ac_srcdir/configure; then
1117       echo
1118       $SHELL $ac_srcdir/configure  --help=recursive
1119     elif test -f $ac_srcdir/configure.ac ||
1120            test -f $ac_srcdir/configure.in; then
1121       echo
1122       $ac_configure --help
1123     else
1124       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1125     fi
1126     cd $ac_popdir
1127   done
1128 fi
1129
1130 test -n "$ac_init_help" && exit 0
1131 if $ac_init_version; then
1132   cat <<\_ACEOF
1133
1134 Copyright (C) 2003 Free Software Foundation, Inc.
1135 This configure script is free software; the Free Software Foundation
1136 gives unlimited permission to copy, distribute and modify it.
1137 _ACEOF
1138   exit 0
1139 fi
1140 exec 5>config.log
1141 cat >&5 <<_ACEOF
1142 This file contains any messages produced by compilers while
1143 running configure, to aid debugging if configure makes a mistake.
1144
1145 It was created by $as_me, which was
1146 generated by GNU Autoconf 2.59.  Invocation command line was
1147
1148   $ $0 $@
1149
1150 _ACEOF
1151 {
1152 cat <<_ASUNAME
1153 ## --------- ##
1154 ## Platform. ##
1155 ## --------- ##
1156
1157 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1158 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1159 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1160 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1161 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1162
1163 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1164 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1165
1166 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1167 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1168 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1169 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1170 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1171 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1172 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1173
1174 _ASUNAME
1175
1176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1177 for as_dir in $PATH
1178 do
1179   IFS=$as_save_IFS
1180   test -z "$as_dir" && as_dir=.
1181   echo "PATH: $as_dir"
1182 done
1183
1184 } >&5
1185
1186 cat >&5 <<_ACEOF
1187
1188
1189 ## ----------- ##
1190 ## Core tests. ##
1191 ## ----------- ##
1192
1193 _ACEOF
1194
1195
1196 # Keep a trace of the command line.
1197 # Strip out --no-create and --no-recursion so they do not pile up.
1198 # Strip out --silent because we don't want to record it for future runs.
1199 # Also quote any args containing shell meta-characters.
1200 # Make two passes to allow for proper duplicate-argument suppression.
1201 ac_configure_args=
1202 ac_configure_args0=
1203 ac_configure_args1=
1204 ac_sep=
1205 ac_must_keep_next=false
1206 for ac_pass in 1 2
1207 do
1208   for ac_arg
1209   do
1210     case $ac_arg in
1211     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1212     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1213     | -silent | --silent | --silen | --sile | --sil)
1214       continue ;;
1215     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1216       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1217     esac
1218     case $ac_pass in
1219     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1220     2)
1221       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1222       if test $ac_must_keep_next = true; then
1223         ac_must_keep_next=false # Got value, back to normal.
1224       else
1225         case $ac_arg in
1226           *=* | --config-cache | -C | -disable-* | --disable-* \
1227           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1228           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1229           | -with-* | --with-* | -without-* | --without-* | --x)
1230             case "$ac_configure_args0 " in
1231               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1232             esac
1233             ;;
1234           -* ) ac_must_keep_next=true ;;
1235         esac
1236       fi
1237       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1238       # Get rid of the leading space.
1239       ac_sep=" "
1240       ;;
1241     esac
1242   done
1243 done
1244 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1245 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1246
1247 # When interrupted or exit'd, cleanup temporary files, and complete
1248 # config.log.  We remove comments because anyway the quotes in there
1249 # would cause problems or look ugly.
1250 # WARNING: Be sure not to use single quotes in there, as some shells,
1251 # such as our DU 5.0 friend, will then `close' the trap.
1252 trap 'exit_status=$?
1253   # Save into config.log some information that might help in debugging.
1254   {
1255     echo
1256
1257     cat <<\_ASBOX
1258 ## ---------------- ##
1259 ## Cache variables. ##
1260 ## ---------------- ##
1261 _ASBOX
1262     echo
1263     # The following way of writing the cache mishandles newlines in values,
1264 {
1265   (set) 2>&1 |
1266     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1267     *ac_space=\ *)
1268       sed -n \
1269         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1270           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1271       ;;
1272     *)
1273       sed -n \
1274         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1275       ;;
1276     esac;
1277 }
1278     echo
1279
1280     cat <<\_ASBOX
1281 ## ----------------- ##
1282 ## Output variables. ##
1283 ## ----------------- ##
1284 _ASBOX
1285     echo
1286     for ac_var in $ac_subst_vars
1287     do
1288       eval ac_val=$`echo $ac_var`
1289       echo "$ac_var='"'"'$ac_val'"'"'"
1290     done | sort
1291     echo
1292
1293     if test -n "$ac_subst_files"; then
1294       cat <<\_ASBOX
1295 ## ------------- ##
1296 ## Output files. ##
1297 ## ------------- ##
1298 _ASBOX
1299       echo
1300       for ac_var in $ac_subst_files
1301       do
1302         eval ac_val=$`echo $ac_var`
1303         echo "$ac_var='"'"'$ac_val'"'"'"
1304       done | sort
1305       echo
1306     fi
1307
1308     if test -s confdefs.h; then
1309       cat <<\_ASBOX
1310 ## ----------- ##
1311 ## confdefs.h. ##
1312 ## ----------- ##
1313 _ASBOX
1314       echo
1315       sed "/^$/d" confdefs.h | sort
1316       echo
1317     fi
1318     test "$ac_signal" != 0 &&
1319       echo "$as_me: caught signal $ac_signal"
1320     echo "$as_me: exit $exit_status"
1321   } >&5
1322   rm -f core *.core &&
1323   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1324     exit $exit_status
1325      ' 0
1326 for ac_signal in 1 2 13 15; do
1327   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1328 done
1329 ac_signal=0
1330
1331 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1332 rm -rf conftest* confdefs.h
1333 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1334 echo >confdefs.h
1335
1336 # Predefined preprocessor variables.
1337
1338 cat >>confdefs.h <<_ACEOF
1339 #define PACKAGE_NAME "$PACKAGE_NAME"
1340 _ACEOF
1341
1342
1343 cat >>confdefs.h <<_ACEOF
1344 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1345 _ACEOF
1346
1347
1348 cat >>confdefs.h <<_ACEOF
1349 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1350 _ACEOF
1351
1352
1353 cat >>confdefs.h <<_ACEOF
1354 #define PACKAGE_STRING "$PACKAGE_STRING"
1355 _ACEOF
1356
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1360 _ACEOF
1361
1362
1363 # Let the site file select an alternate cache file if it wants to.
1364 # Prefer explicitly selected file to automatically selected ones.
1365 if test -z "$CONFIG_SITE"; then
1366   if test "x$prefix" != xNONE; then
1367     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1368   else
1369     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1370   fi
1371 fi
1372 for ac_site_file in $CONFIG_SITE; do
1373   if test -r "$ac_site_file"; then
1374     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1375 echo "$as_me: loading site script $ac_site_file" >&6;}
1376     sed 's/^/| /' "$ac_site_file" >&5
1377     . "$ac_site_file"
1378   fi
1379 done
1380
1381 if test -r "$cache_file"; then
1382   # Some versions of bash will fail to source /dev/null (special
1383   # files actually), so we avoid doing that.
1384   if test -f "$cache_file"; then
1385     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1386 echo "$as_me: loading cache $cache_file" >&6;}
1387     case $cache_file in
1388       [\\/]* | ?:[\\/]* ) . $cache_file;;
1389       *)                      . ./$cache_file;;
1390     esac
1391   fi
1392 else
1393   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1394 echo "$as_me: creating cache $cache_file" >&6;}
1395   >$cache_file
1396 fi
1397
1398 # Check that the precious variables saved in the cache have kept the same
1399 # value.
1400 ac_cache_corrupted=false
1401 for ac_var in `(set) 2>&1 |
1402                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1403   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1404   eval ac_new_set=\$ac_env_${ac_var}_set
1405   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1406   eval ac_new_val="\$ac_env_${ac_var}_value"
1407   case $ac_old_set,$ac_new_set in
1408     set,)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,set)
1413       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1414 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1415       ac_cache_corrupted=: ;;
1416     ,);;
1417     *)
1418       if test "x$ac_old_val" != "x$ac_new_val"; then
1419         # differences in whitespace do not lead to failure.
1420         ac_old_val_w=`echo x $ac_old_val`
1421         ac_new_val_w=`echo x $ac_new_val`
1422         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1423           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1424 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1425           ac_cache_corrupted=:
1426         else
1427           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1428 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1429           eval $ac_var=\$ac_old_val
1430         fi
1431         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1432 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1433         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1434 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1435       fi;;
1436   esac
1437   # Pass precious variables to config.status.
1438   if test "$ac_new_set" = set; then
1439     case $ac_new_val in
1440     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1441       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1442     *) ac_arg=$ac_var=$ac_new_val ;;
1443     esac
1444     case " $ac_configure_args " in
1445       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1446       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1447     esac
1448   fi
1449 done
1450 if $ac_cache_corrupted; then
1451   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1452 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1453   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1454 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1455   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1456 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1457    { (exit 1); exit 1; }; }
1458 fi
1459
1460 ac_ext=c
1461 ac_cpp='$CPP $CPPFLAGS'
1462 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1463 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1464 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489 progname=$0
1490 # if PWD already has a value, it is probably wrong.
1491 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1492
1493 # Export original configure arguments for use by sub-configures.
1494 # Quote arguments with shell meta charatcers.
1495 TOPLEVEL_CONFIGURE_ARGUMENTS=
1496 set -- "$progname" "$@"
1497 for ac_arg
1498 do
1499   case "$ac_arg" in
1500   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1501     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1502     # if the argument is of the form -foo=baz, quote the baz part only
1503     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1504   *) ;;
1505   esac
1506   # Add the quoted argument to the list.
1507   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1508 done
1509 if test "$silent" = yes; then
1510   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1511 fi
1512 # Remove the initial space we just introduced and, as these will be
1513 # expanded by make, quote '$'.
1514 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1515
1516
1517 # Find the build, host, and target systems.
1518 ac_aux_dir=
1519 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1520   if test -f $ac_dir/install-sh; then
1521     ac_aux_dir=$ac_dir
1522     ac_install_sh="$ac_aux_dir/install-sh -c"
1523     break
1524   elif test -f $ac_dir/install.sh; then
1525     ac_aux_dir=$ac_dir
1526     ac_install_sh="$ac_aux_dir/install.sh -c"
1527     break
1528   elif test -f $ac_dir/shtool; then
1529     ac_aux_dir=$ac_dir
1530     ac_install_sh="$ac_aux_dir/shtool install -c"
1531     break
1532   fi
1533 done
1534 if test -z "$ac_aux_dir"; then
1535   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1536 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1537    { (exit 1); exit 1; }; }
1538 fi
1539 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1540 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1541 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1542
1543 # Make sure we can run config.sub.
1544 $ac_config_sub sun4 >/dev/null 2>&1 ||
1545   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1546 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1547    { (exit 1); exit 1; }; }
1548
1549 echo "$as_me:$LINENO: checking build system type" >&5
1550 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1551 if test "${ac_cv_build+set}" = set; then
1552   echo $ECHO_N "(cached) $ECHO_C" >&6
1553 else
1554   ac_cv_build_alias=$build_alias
1555 test -z "$ac_cv_build_alias" &&
1556   ac_cv_build_alias=`$ac_config_guess`
1557 test -z "$ac_cv_build_alias" &&
1558   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1559 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1560    { (exit 1); exit 1; }; }
1561 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1562   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1563 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1564    { (exit 1); exit 1; }; }
1565
1566 fi
1567 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1568 echo "${ECHO_T}$ac_cv_build" >&6
1569 build=$ac_cv_build
1570 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1571 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1572 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1573
1574
1575  case ${build_alias} in
1576   "") build_noncanonical=${build} ;;
1577   *) build_noncanonical=${build_alias} ;;
1578 esac
1579
1580
1581
1582  case ${host_alias} in
1583   "") host_noncanonical=${build_noncanonical} ;;
1584   *) host_noncanonical=${host_alias} ;;
1585 esac
1586
1587
1588
1589  case ${target_alias} in
1590   "") target_noncanonical=${host_noncanonical} ;;
1591   *) target_noncanonical=${target_alias} ;;
1592 esac
1593
1594
1595
1596
1597 test "$host_noncanonical" = "$target_noncanonical" &&
1598   test "$program_prefix$program_suffix$program_transform_name" = \
1599     NONENONEs,x,x, &&
1600   program_transform_name=s,y,y,
1601
1602 echo "$as_me:$LINENO: checking host system type" >&5
1603 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1604 if test "${ac_cv_host+set}" = set; then
1605   echo $ECHO_N "(cached) $ECHO_C" >&6
1606 else
1607   ac_cv_host_alias=$host_alias
1608 test -z "$ac_cv_host_alias" &&
1609   ac_cv_host_alias=$ac_cv_build_alias
1610 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1611   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1612 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1613    { (exit 1); exit 1; }; }
1614
1615 fi
1616 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1617 echo "${ECHO_T}$ac_cv_host" >&6
1618 host=$ac_cv_host
1619 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1620 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1621 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1622
1623
1624 echo "$as_me:$LINENO: checking target system type" >&5
1625 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1626 if test "${ac_cv_target+set}" = set; then
1627   echo $ECHO_N "(cached) $ECHO_C" >&6
1628 else
1629   ac_cv_target_alias=$target_alias
1630 test "x$ac_cv_target_alias" = "x" &&
1631   ac_cv_target_alias=$ac_cv_host_alias
1632 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1633   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1634 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1635    { (exit 1); exit 1; }; }
1636
1637 fi
1638 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1639 echo "${ECHO_T}$ac_cv_target" >&6
1640 target=$ac_cv_target
1641 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1642 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1643 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1644
1645
1646 # The aliases save the names the user supplied, while $host etc.
1647 # will get canonicalized.
1648 test -n "$target_alias" &&
1649   test "$program_prefix$program_suffix$program_transform_name" = \
1650     NONENONEs,x,x, &&
1651   program_prefix=${target_alias}-
1652 test "$program_prefix" != NONE &&
1653   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1654 # Use a double $ so make ignores it.
1655 test "$program_suffix" != NONE &&
1656   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1657 # Double any \ or $.  echo might interpret backslashes.
1658 # By default was `s,x,x', remove it if useless.
1659 cat <<\_ACEOF >conftest.sed
1660 s/[\\$]/&&/g;s/;s,x,x,$//
1661 _ACEOF
1662 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1663 rm conftest.sed
1664
1665
1666
1667 # Get 'install' or 'install-sh' and its variants.
1668 # Find a good install program.  We prefer a C program (faster),
1669 # so one script is as good as another.  But avoid the broken or
1670 # incompatible versions:
1671 # SysV /etc/install, /usr/sbin/install
1672 # SunOS /usr/etc/install
1673 # IRIX /sbin/install
1674 # AIX /bin/install
1675 # AmigaOS /C/install, which installs bootblocks on floppy discs
1676 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1677 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1678 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1679 # OS/2's system install, which has a completely different semantic
1680 # ./install, which can be erroneously created by make from ./install.sh.
1681 # Reject install programs that cannot install multiple files.
1682 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1683 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1684 if test -z "$INSTALL"; then
1685 if test "${ac_cv_path_install+set}" = set; then
1686   echo $ECHO_N "(cached) $ECHO_C" >&6
1687 else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689 for as_dir in $PATH
1690 do
1691   IFS=$as_save_IFS
1692   test -z "$as_dir" && as_dir=.
1693   # Account for people who put trailing slashes in PATH elements.
1694 case $as_dir/ in
1695   ./ | .// | /cC/* | \
1696   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1697   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1698   /usr/ucb/* ) ;;
1699   *)
1700     # OSF1 and SCO ODT 3.0 have their own names for install.
1701     # Don't use installbsd from OSF since it installs stuff as root
1702     # by default.
1703     for ac_prog in ginstall scoinst install; do
1704       for ac_exec_ext in '' $ac_executable_extensions; do
1705         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1706           if test $ac_prog = install &&
1707             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1708             # AIX install.  It has an incompatible calling convention.
1709             :
1710           elif test $ac_prog = install &&
1711             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1712             # program-specific install script used by HP pwplus--don't use.
1713             :
1714           else
1715             rm -rf conftest.one conftest.two conftest.dir
1716             echo one > conftest.one
1717             echo two > conftest.two
1718             mkdir conftest.dir
1719             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1720               test -s conftest.one && test -s conftest.two &&
1721               test -s conftest.dir/conftest.one &&
1722               test -s conftest.dir/conftest.two
1723             then
1724               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1725               break 3
1726             fi
1727           fi
1728         fi
1729       done
1730     done
1731     ;;
1732 esac
1733 done
1734
1735 rm -rf conftest.one conftest.two conftest.dir
1736
1737 fi
1738   if test "${ac_cv_path_install+set}" = set; then
1739     INSTALL=$ac_cv_path_install
1740   else
1741     # As a last resort, use the slow shell script.  Don't cache a
1742     # value for INSTALL within a source directory, because that will
1743     # break other packages using the cache if that directory is
1744     # removed, or if the value is a relative name.
1745     INSTALL=$ac_install_sh
1746   fi
1747 fi
1748 echo "$as_me:$LINENO: result: $INSTALL" >&5
1749 echo "${ECHO_T}$INSTALL" >&6
1750
1751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1752 # It thinks the first close brace ends the variable substitution.
1753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1754
1755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1756
1757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1758
1759 echo "$as_me:$LINENO: checking whether ln works" >&5
1760 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1761 if test "${acx_cv_prog_LN+set}" = set; then
1762   echo $ECHO_N "(cached) $ECHO_C" >&6
1763 else
1764   rm -f conftestdata_t
1765 echo >conftestdata_f
1766 if ln conftestdata_f conftestdata_t 2>/dev/null
1767 then
1768   acx_cv_prog_LN=ln
1769 else
1770   acx_cv_prog_LN=no
1771 fi
1772 rm -f conftestdata_f conftestdata_t
1773
1774 fi
1775 if test $acx_cv_prog_LN = no; then
1776   LN="cp"
1777   echo "$as_me:$LINENO: result: no, using $LN" >&5
1778 echo "${ECHO_T}no, using $LN" >&6
1779 else
1780   LN="$acx_cv_prog_LN"
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783 fi
1784
1785 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1786 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1787 LN_S=$as_ln_s
1788 if test "$LN_S" = "ln -s"; then
1789   echo "$as_me:$LINENO: result: yes" >&5
1790 echo "${ECHO_T}yes" >&6
1791 else
1792   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1793 echo "${ECHO_T}no, using $LN_S" >&6
1794 fi
1795
1796
1797 ### we might need to use some other shell than /bin/sh for running subshells
1798 ### If we are on Windows, search for the shell.  This will permit people
1799 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1800 ### without also having to set CONFIG_SHELL.  This code will work when
1801 ### using bash, which sets OSTYPE.
1802 case "${OSTYPE}" in
1803 *win32*)
1804   if test x${CONFIG_SHELL} = x ; then
1805     if test ! -f /bin/sh ; then
1806       if test x${SHELL} != x && test -f ${SHELL} ; then
1807         CONFIG_SHELL=${SHELL}
1808         export CONFIG_SHELL
1809       else
1810         for prog in sh sh.exe bash bash.exe; do
1811           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1812           for dir in $PATH; do
1813             test -z "$dir" && dir=.
1814             if test -f $dir/$prog; then
1815               CONFIG_SHELL=$dir/$prog
1816               export CONFIG_SHELL
1817               break
1818             fi
1819           done
1820           IFS="$save_ifs"
1821           test -n "${CONFIG_SHELL}" && break
1822         done
1823       fi
1824     fi
1825   fi
1826   ;;
1827 esac
1828
1829 config_shell=${CONFIG_SHELL-/bin/sh}
1830
1831 moveifchange=${srcdir}/move-if-change
1832
1833 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1834
1835 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1836 # a relative path.
1837 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1838   INSTALL="${srcpwd}/install-sh -c"
1839 fi
1840
1841 # Set srcdir to "." if that's what it is.
1842 # This is important for multilib support.
1843 pwd=`${PWDCMD-pwd}`
1844 if test "${pwd}" = "${srcpwd}" ; then
1845   srcdir=.
1846 fi
1847
1848 topsrcdir=$srcpwd
1849
1850 extra_host_args=
1851
1852 ### To add a new directory to the tree, first choose whether it is a target
1853 ### or a host dependent tool.  Then put it into the appropriate list
1854 ### (library or tools, host or target), doing a dependency sort.
1855
1856 # Subdirs will be configured in the order listed in build_configdirs,
1857 # configdirs, or target_configdirs; see the serialization section below.
1858
1859 # Dependency sorting is only needed when *configuration* must be done in
1860 # a particular order.  In all cases a dependency should be specified in
1861 # the Makefile, whether or not it's implicitly specified here.
1862
1863 # Double entries in build_configdirs, configdirs, or target_configdirs may
1864 # cause circular dependencies and break everything horribly.
1865
1866 # these library is used by various programs built for the build
1867 # environment
1868 #
1869 build_libs="build-libiberty"
1870
1871 # these tools are built for the build environment
1872 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1873
1874 # these libraries are used by various programs built for the host environment
1875 #
1876 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1877
1878 # these tools are built for the host environment
1879 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1880 # know that we are building the simulator.
1881 # binutils, gas and ld appear in that order because it makes sense to run
1882 # "make check" in that particular order.
1883 # If --enable-gold is used, "gold" will replace "ld".
1884 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1885
1886 # libgcj represents the runtime libraries only used by gcj.
1887 libgcj="target-libffi \
1888         target-zlib \
1889         target-qthreads \
1890         target-libjava"
1891
1892 # these libraries are built for the target environment, and are built after
1893 # the host libraries and the host tools (which may be a cross compiler)
1894 #
1895 target_libraries="target-libgcc \
1896                 target-libiberty \
1897                 target-libgloss \
1898                 target-newlib \
1899                 target-libgomp \
1900                 target-libstdc++-v3 \
1901                 target-libmudflap \
1902                 target-libssp \
1903                 target-libgfortran \
1904                 target-boehm-gc \
1905                 ${libgcj} \
1906                 target-libobjc \
1907                 target-libada"
1908
1909 # these tools are built using the target libraries, and are intended to
1910 # run only in the target environment
1911 #
1912 # note: any program that *uses* libraries that are in the "target_libraries"
1913 # list belongs in this list.  those programs are also very likely
1914 # candidates for the "native_only" list which follows
1915 #
1916 target_tools="target-examples target-groff target-gperf target-rda"
1917
1918 ################################################################################
1919
1920 ## All tools belong in one of the four categories, and are assigned above
1921 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1922 ## is important because configure will choke if they ever get through.
1923 ## ${configdirs} is directories we build using the host tools.
1924 ## ${target_configdirs} is directories we build using the target tools.
1925 configdirs=`echo ${host_libs} ${host_tools}`
1926 target_configdirs=`echo ${target_libraries} ${target_tools}`
1927 build_configdirs=`echo ${build_libs} ${build_tools}`
1928
1929
1930
1931 ################################################################################
1932
1933 srcname="gnu development package"
1934
1935 # This gets set non-empty for some net releases of packages.
1936 appdirs=""
1937
1938 # Define is_cross_compiler to save on calls to 'test'.
1939 is_cross_compiler=
1940 if test x"${host}" = x"${target}" ; then
1941   is_cross_compiler=no
1942 else
1943   is_cross_compiler=yes
1944 fi
1945
1946 # Find the build and target subdir names.
1947
1948 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1949 # have matching libraries, they should use host libraries: Makefile.tpl
1950 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1951 # However, they still use the build modules, because the corresponding
1952 # host modules (e.g. bison) are only built for the host when bootstrap
1953 # finishes. So:
1954 # - build_subdir is where we find build modules, and never changes.
1955 # - build_libsubdir is where we find build libraries, and can be overridden.
1956
1957 # Prefix 'build-' so this never conflicts with target_subdir.
1958 build_subdir="build-${build_noncanonical}"
1959
1960 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1961 if test "${with_build_libsubdir+set}" = set; then
1962   withval="$with_build_libsubdir"
1963   build_libsubdir="$withval"
1964 else
1965   build_libsubdir="$build_subdir"
1966 fi;
1967 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1968 if ( test $srcdir = . && test -d gcc ) \
1969    || test -d $srcdir/../host-${host_noncanonical}; then
1970   host_subdir="host-${host_noncanonical}"
1971 else
1972   host_subdir=.
1973 fi
1974 # No prefix.
1975 target_subdir=${target_noncanonical}
1976
1977
1978 # Skipdirs are removed silently.
1979 skipdirs=
1980 # Noconfigdirs are removed loudly.
1981 noconfigdirs=""
1982
1983 use_gnu_ld=
1984 # Make sure we don't let GNU ld be added if we didn't want it.
1985 if test x$with_gnu_ld = xno ; then
1986   use_gnu_ld=no
1987   noconfigdirs="$noconfigdirs ld gold"
1988 fi
1989
1990 use_gnu_as=
1991 # Make sure we don't let GNU as be added if we didn't want it.
1992 if test x$with_gnu_as = xno ; then
1993   use_gnu_as=no
1994   noconfigdirs="$noconfigdirs gas"
1995 fi
1996
1997 # some tools are so dependent upon X11 that if we're not building with X,
1998 # it's not even worth trying to configure, much less build, that tool.
1999
2000 case ${with_x} in
2001   yes | "") ;; # the default value for this tree is that X11 is available
2002   no)
2003     skipdirs="${skipdirs} tk itcl libgui"
2004     # We won't be able to build gdbtk without X.
2005     enable_gdbtk=no
2006     ;;
2007   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2008 esac
2009
2010 # Some tools are only suitable for building in a "native" situation.
2011 # Remove these if host!=target.
2012 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2013
2014 # Similarly, some are only suitable for cross toolchains.
2015 # Remove these if host=target.
2016 cross_only="target-libgloss target-newlib target-opcodes"
2017
2018 case $is_cross_compiler in
2019   no) skipdirs="${skipdirs} ${cross_only}" ;;
2020   yes) skipdirs="${skipdirs} ${native_only}" ;;
2021 esac
2022
2023 # If both --with-headers and --with-libs are specified, default to
2024 # --without-newlib.
2025 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2026    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2027   if test x"${with_newlib}" = x ; then
2028     with_newlib=no
2029   fi
2030 fi
2031
2032 # Recognize --with-newlib/--without-newlib.
2033 case ${with_newlib} in
2034   no) skipdirs="${skipdirs} target-newlib" ;;
2035   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2036 esac
2037
2038 # Handle --enable-gold.
2039
2040 # Check whether --enable-gold or --disable-gold was given.
2041 if test "${enable_gold+set}" = set; then
2042   enableval="$enable_gold"
2043   ENABLE_GOLD=$enableval
2044 else
2045   ENABLE_GOLD=no
2046 fi;
2047 if test "${ENABLE_GOLD}" = "yes"; then
2048   # Check for ELF target.
2049   is_elf=no
2050   case "${target}" in
2051     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2052     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2053     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2054       case "${target}" in
2055         *-*-linux*aout* | *-*-linux*oldld*)
2056           ;;
2057         *)
2058           is_elf=yes
2059           ;;
2060       esac
2061   esac
2062
2063   if test "$is_elf" = "yes"; then
2064     # Check for target supported by gold.
2065     case "${target}" in
2066       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2067         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2068         ;;
2069     esac
2070   fi
2071 fi
2072
2073 # Configure extra directories which are host specific
2074
2075 case "${host}" in
2076   *-cygwin*)
2077     configdirs="$configdirs libtermcap" ;;
2078 esac
2079
2080 # A target can indicate whether a language isn't supported for some reason.
2081 # Only spaces may be used in this macro; not newlines or tabs.
2082 unsupported_languages=
2083
2084 # Remove more programs from consideration, based on the host or
2085 # target this usually means that a port of the program doesn't
2086 # exist yet.
2087
2088 case "${host}" in
2089   hppa*64*-*-*)
2090     noconfigdirs="$noconfigdirs byacc"
2091     ;;
2092   i[3456789]86-*-vsta)
2093     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2094     ;;
2095   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2096     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2097     ;;
2098   x86_64-*-mingw*)
2099     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2100     ;;
2101   i[3456789]86-*-mingw32*)
2102     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2103     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2104     ;;
2105   i[3456789]86-*-beos*)
2106     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2107     ;;
2108   *-*-cygwin*)
2109     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2110     ;;
2111   *-*-netbsd*)
2112     noconfigdirs="$noconfigdirs rcs"
2113     ;;
2114   ppc*-*-pe)
2115     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2116     ;;
2117   powerpc-*-beos*)
2118     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2119     ;;
2120 esac
2121
2122
2123 # Check whether --enable-libada or --disable-libada was given.
2124 if test "${enable_libada+set}" = set; then
2125   enableval="$enable_libada"
2126   ENABLE_LIBADA=$enableval
2127 else
2128   ENABLE_LIBADA=yes
2129 fi;
2130 if test "${ENABLE_LIBADA}" != "yes" ; then
2131   noconfigdirs="$noconfigdirs gnattools"
2132 fi
2133
2134 # Check whether --enable-libssp or --disable-libssp was given.
2135 if test "${enable_libssp+set}" = set; then
2136   enableval="$enable_libssp"
2137   ENABLE_LIBSSP=$enableval
2138 else
2139   ENABLE_LIBSSP=yes
2140 fi;
2141
2142 # Save it here so that, even in case of --enable-libgcj, if the Java
2143 # front-end isn't enabled, we still get libgcj disabled.
2144 libgcj_saved=$libgcj
2145 case $enable_libgcj in
2146 yes)
2147   # If we reset it here, it won't get added to noconfigdirs in the
2148   # target-specific build rules, so it will be forcibly enabled
2149   # (unless the Java language itself isn't enabled).
2150   libgcj=
2151   ;;
2152 no)
2153   # Make sure we get it printed in the list of not supported target libs.
2154   noconfigdirs="$noconfigdirs ${libgcj}"
2155   ;;
2156 esac
2157
2158
2159 # Disable libmudflap on some systems.
2160 if test x$enable_libmudflap = x ; then
2161     case "${target}" in
2162     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2163         # Enable libmudflap by default in GNU and friends.
2164         ;;
2165     *-*-freebsd*)
2166         # Enable libmudflap by default in FreeBSD.
2167         ;;
2168     *)
2169         # Disable it by default everywhere else.
2170         noconfigdirs="$noconfigdirs target-libmudflap"
2171         ;;
2172     esac
2173 fi
2174
2175 # Disable libgomp on non POSIX hosted systems.
2176 if test x$enable_libgomp = x ; then
2177     # Enable libgomp by default on hosted POSIX systems.
2178     case "${target}" in
2179     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2180         ;;
2181     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2182         ;;
2183     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2184         ;;
2185     *-*-darwin* | *-*-aix*)
2186         ;;
2187     *)
2188         noconfigdirs="$noconfigdirs target-libgomp"
2189         ;;
2190     esac
2191 fi
2192
2193 # Default libgloss CPU subdirectory.
2194 libgloss_dir="$target_cpu"
2195
2196 case "${target}" in
2197   *-*-chorusos)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2199     ;;
2200   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2201     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2202     noconfigdirs="$noconfigdirs sim target-rda"
2203     ;;
2204   *-*-darwin*)
2205     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2206     noconfigdirs="$noconfigdirs sim target-rda"
2207     noconfigdirs="$noconfigdirs ${libgcj}"
2208     ;;
2209   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2210     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2211     ;;
2212   *-*-freebsd*)
2213     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2214     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2215         && test -f /usr/local/include/gmp.h; then
2216       with_gmp=/usr/local
2217     fi
2218
2219     # Skip some stuff that's unsupported on some FreeBSD configurations.
2220     case "${target}" in
2221       i*86-*-*) ;;
2222       alpha*-*-*) ;;
2223       *)
2224         noconfigdirs="$noconfigdirs ${libgcj}"
2225         ;;
2226     esac
2227     ;;
2228   *-*-kaos*)
2229     # Remove unsupported stuff on all kaOS configurations.
2230     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2231     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2232     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2233     noconfigdirs="$noconfigdirs target-libgloss"
2234     ;;
2235   *-*-netbsd*)
2236     # Skip some stuff on all NetBSD configurations.
2237     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2238
2239     # Skip some stuff that's unsupported on some NetBSD configurations.
2240     case "${target}" in
2241       i*86-*-netbsdelf*) ;;
2242       arm*-*-netbsdelf*) ;;
2243       *)
2244         noconfigdirs="$noconfigdirs ${libgcj}"
2245         ;;
2246     esac
2247     ;;
2248   *-*-netware*)
2249     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2250     ;;
2251   *-*-rtems*)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254     # The tpf target doesn't support gdb yet.
2255   *-*-tpf*)
2256     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2257     ;;
2258   *-*-uclinux*)
2259     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2260     ;;
2261   *-*-vxworks*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2263     ;;
2264   alpha*-dec-osf*)
2265     # ld works, but does not support shared libraries.
2266     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2267     # gas doesn't generate exception information.
2268     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2269     ;;
2270   alpha*-*-*vms*)
2271     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2272     ;;
2273   alpha*-*-linux*)
2274     # newlib is not 64 bit ready
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2276     ;;
2277   alpha*-*-*)
2278     # newlib is not 64 bit ready
2279     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2280     ;;
2281   am33_2.0-*-linux*)
2282     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2283     ;;
2284   sh-*-linux*)
2285     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2286     ;;
2287   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2288     noconfigdirs="$noconfigdirs ${libgcj}"
2289     noconfigdirs="$noconfigdirs target-examples"
2290     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2291     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2292     noconfigdirs="$noconfigdirs expect dejagnu"
2293     # the C++ libraries don't build on top of CE's C libraries
2294     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2295     noconfigdirs="$noconfigdirs target-newlib"
2296     case "${host}" in
2297       *-*-cygwin*) ;; # keep gdb and readline
2298       *) noconfigdirs="$noconfigdirs gdb readline"
2299          ;;
2300     esac
2301     libgloss_dir=wince
2302     ;;
2303   arc-*-*)
2304     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2305     ;;
2306   arm-semi-aof )
2307     ;;
2308   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2309     noconfigdirs="$noconfigdirs ${libgcj}"
2310     libgloss_dir=arm
2311     ;;
2312   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2313     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2314     libgloss_dir=arm
2315     ;;
2316   arm*-*-linux-gnueabi)
2317     noconfigdirs="$noconfigdirs target-qthreads"
2318     case ${with_newlib} in
2319       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2320     esac
2321     libgloss_dir=arm
2322     ;;
2323   arm*-*-symbianelf*)
2324     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2325     libgloss_dir=arm
2326     ;;
2327   arm-*-pe*)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   thumb-*-coff)
2331     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2332     ;;
2333   thumb-*-elf)
2334     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2335     ;;
2336   thumb-*-pe)
2337     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2338     ;;
2339   arm-*-riscix*)
2340     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2341     ;;
2342   avr-*-*)
2343     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2344     ;;
2345   bfin-*-*)
2346     noconfigdirs="$noconfigdirs gdb"
2347     if test x${is_cross_compiler} != xno ; then
2348       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2349     fi
2350     ;;
2351   c4x-*-* | tic4x-*-*)
2352     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2353     ;;
2354   c54x*-*-* | tic54x-*-*)
2355     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2356     ;;
2357   cr16-*-*)
2358     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2359     ;;
2360   cris-*-* | crisv32-*-*)
2361     unsupported_languages="$unsupported_languages java"
2362     case "${target}" in
2363       *-*-aout)
2364         unsupported_languages="$unsupported_languages fortran"
2365         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2366       *-*-elf)
2367         noconfigdirs="$noconfigdirs target-boehm-gc";;
2368       *-*-linux*)
2369         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2370       *)
2371         unsupported_languages="$unsupported_languages fortran"
2372         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2373     esac
2374     libgloss_dir=cris
2375     ;;
2376   crx-*-*)
2377     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2378     ;;
2379   d10v-*-*)
2380     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2381     ;;
2382   d30v-*-*)
2383     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2384     ;;
2385   ep9312-*-elf | ep9312-*-coff)
2386     libgloss_dir=arm
2387     ;;
2388   fr30-*-elf*)
2389     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2390     ;;
2391   frv-*-*)
2392     noconfigdirs="$noconfigdirs ${libgcj}"
2393     ;;
2394   h8300*-*-*)
2395     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2396     ;;
2397   h8500-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2401     ;;
2402   hppa*64*-*-linux* | parisc*64*-*-linux*)
2403     # In this case, it's because the hppa64-linux target is for
2404     # the kernel only at this point and has no libc, and thus no
2405     # headers, crt*.o, etc., all of which are needed by these.
2406     noconfigdirs="$noconfigdirs target-zlib"
2407     ;;
2408   parisc*-*-linux* | hppa*-*-linux*)
2409     ;;
2410   hppa*-*-*elf* | \
2411   hppa*-*-lites* | \
2412   hppa*-*-openbsd* | \
2413   hppa*64*-*-*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   hppa*-hp-hpux11*)
2417     noconfigdirs="$noconfigdirs ld shellutils"
2418     ;;
2419   hppa*-*-pro*)
2420     libgloss_dir=pa
2421     ;;
2422   hppa*-*-*)
2423     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2424     # build on HP-UX 10.20.
2425     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2426     ;;
2427   i960-*-*)
2428     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2429     ;;
2430   ia64*-*-elf*)
2431     # No gdb support yet.
2432     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2433     ;;
2434   ia64*-**-hpux*)
2435     # No gdb or ld support yet.
2436     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2437     ;;
2438   i370-*-opened*)
2439     ;;
2440   i[3456789]86-*-coff | i[3456789]86-*-elf)
2441     noconfigdirs="$noconfigdirs ${libgcj}"
2442     libgloss_dir=i386
2443     ;;
2444   i[3456789]86-*-linux*)
2445     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2446     # not build java stuff by default.
2447     case "${target}" in
2448       *-*-*libc1*)
2449         noconfigdirs="$noconfigdirs ${libgcj}";;
2450     esac
2451
2452     # This section makes it possible to build newlib natively on linux.
2453     # If we are using a cross compiler then don't configure newlib.
2454     if test x${is_cross_compiler} != xno ; then
2455       noconfigdirs="$noconfigdirs target-newlib"
2456     fi
2457     noconfigdirs="$noconfigdirs target-libgloss"
2458     # If we are not using a cross compiler, do configure newlib.
2459     # Note however, that newlib will only be configured in this situation
2460     # if the --with-newlib option has been given, because otherwise
2461     # 'target-newlib' will appear in skipdirs.
2462     ;;
2463   i[3456789]86-*-mingw32*)
2464     target_configdirs="$target_configdirs target-winsup"
2465     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2466     ;;
2467   x86_64-*-mingw*)
2468     target_configdirs="$target_configdirs target-winsup"
2469     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2470     ;;
2471   *-*-cygwin*)
2472     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2473     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2474     # always build newlib if winsup directory is present.
2475     if test -d "$srcdir/winsup/cygwin"; then
2476       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2477     elif test -d "$srcdir/newlib"; then
2478       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2479     fi
2480     ;;
2481   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2482   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2483     ;;
2484   i[3456789]86-*-pe)
2485     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-sco3.2v5*)
2488     # The linker does not yet know about weak symbols in COFF,
2489     # and is not configured to handle mixed ELF and COFF.
2490     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2491     ;;
2492   i[3456789]86-*-sco*)
2493     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2494     ;;
2495   i[3456789]86-*-solaris2*)
2496     noconfigdirs="$noconfigdirs target-libgloss"
2497     ;;
2498   i[3456789]86-*-sysv4*)
2499     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2500     ;;
2501   i[3456789]86-*-beos*)
2502     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2503     ;;
2504   i[3456789]86-*-rdos*)
2505     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2506     ;;
2507   m32r-*-*)
2508     noconfigdirs="$noconfigdirs ${libgcj}"
2509     ;;
2510   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2511     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2512     libgloss_dir=m68hc11
2513     ;;
2514   m68k-*-elf*)
2515     noconfigdirs="$noconfigdirs ${libgcj}"
2516     ;;
2517   m68k-*-coff*)
2518     noconfigdirs="$noconfigdirs ${libgcj}"
2519     ;;
2520   m68*-*-* | fido-*-*)
2521     libgloss_dir=m68k
2522     ;;
2523   mcore-*-pe*)
2524   # The EPOC C++ environment does not support exceptions or rtti,
2525   # and so building libstdc++-v3 tends not to always work.
2526     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2527     ;;
2528   mmix-*-*)
2529     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2530     unsupported_languages="$unsupported_languages fortran java"
2531     ;;
2532   mn10200-*-*)
2533     noconfigdirs="$noconfigdirs ${libgcj}"
2534     ;;
2535   mn10300-*-*)
2536     noconfigdirs="$noconfigdirs ${libgcj}"
2537     ;;
2538   mt-*-*)
2539     noconfigdirs="$noconfigdirs sim"
2540     ;;
2541   powerpc-*-aix*)
2542     # copied from rs6000-*-* entry
2543     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2544     ;;
2545   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2546     target_configdirs="$target_configdirs target-winsup"
2547     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2548     # always build newlib.
2549     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2550     ;;
2551     # This is temporary until we can link against shared libraries
2552   powerpcle-*-solaris*)
2553     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2554     libgloss_dir=rs6000
2555     ;;
2556   powerpc-*-beos*)
2557     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2558     ;;
2559   powerpc-*-eabi)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=rs6000
2562     ;;
2563   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2564     libgloss_dir=rs6000
2565     ;;
2566   rs6000-*-lynxos*)
2567     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2568     ;;
2569   rs6000-*-aix*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2571     ;;
2572   rs6000-*-*)
2573     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2574     ;;
2575   m68k-apollo-*)
2576     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2577     ;;
2578   mips*-sde-elf*)
2579     skipdirs="$skipdirs target-libiberty"
2580     noconfigdirs="$noconfigdirs ${libgcj}"
2581     if test x$with_newlib = xyes; then
2582       noconfigdirs="$noconfigdirs gprof"
2583     fi
2584     libgloss_dir=mips
2585     ;;
2586   mips*-*-irix5*)
2587     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2588     ;;
2589   mips*-*-irix6*)
2590     # Linking libjava exceeds command-line length limits on at least
2591     # IRIX 6.2, but not on IRIX 6.5.
2592     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2593     # <oldham@codesourcery.com>
2594     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2595     ;;
2596   mips*-*-bsd*)
2597     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2598     ;;
2599   mips*-*-linux*)
2600     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2601     ;;
2602   mips*-*-*)
2603     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2604     libgloss_dir=mips
2605     ;;
2606   romp-*-*)
2607     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2608     ;;
2609   sh-*-* | sh64-*-*)
2610     case "${host}" in
2611       i[3456789]86-*-vsta) ;; # don't add gprof back in
2612       i[3456789]86-*-go32*) ;; # don't add gprof back in
2613       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2614       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2615     esac
2616     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2617     ;;
2618   sparclet-*-aout* | sparc86x-*-*)
2619     libgloss_dir=sparc
2620     ;;
2621   sparc-*-elf*)
2622     noconfigdirs="$noconfigdirs ${libgcj}"
2623     ;;
2624   sparc64-*-elf*)
2625     noconfigdirs="$noconfigdirs ${libgcj}"
2626     libgloss_dir=sparc
2627     ;;
2628   sparclite-*-*)
2629     noconfigdirs="$noconfigdirs ${libgcj}"
2630     libgloss_dir=sparc
2631     ;;
2632   sparc-*-sunos4*)
2633     noconfigdirs="$noconfigdirs ${libgcj}"
2634     if test x${is_cross_compiler} != xno ; then
2635            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2636     else
2637            use_gnu_ld=no
2638     fi
2639     ;;
2640   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2641     noconfigdirs="$noconfigdirs ${libgcj}"
2642     ;;
2643   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2644     ;;
2645   spu-*-*)
2646     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 # Decide which environment variable is used to find dynamic libraries.
5598 case "${host}" in
5599   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5600   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5601   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5602   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5603 esac
5604
5605 # On systems where the dynamic library environment variable is PATH,
5606 if test "$RPATH_ENVVAR" = PATH; then
5607   GCC_SHLIB_SUBDIR=/shlib
5608 else
5609   GCC_SHLIB_SUBDIR=
5610 fi
5611
5612 # Record target_configdirs and the configure arguments for target and
5613 # build configuration in Makefile.
5614 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5615 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5616
5617 # Determine whether gdb needs tk/tcl or not.
5618 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5619 # and in that case we want gdb to be built without tk.  Ugh!
5620 # In fact I believe gdb is the *only* package directly dependent on tk,
5621 # so we should be able to put the 'maybe's in unconditionally and
5622 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5623 # 100% sure that that's safe though.
5624
5625 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5626 case "$enable_gdbtk" in
5627   no)
5628     GDB_TK="" ;;
5629   yes)
5630     GDB_TK="${gdb_tk}" ;;
5631   *)
5632     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5633     # distro.  Eventually someone will fix this and move Insight, nee
5634     # gdbtk to a separate directory.
5635     if test -d ${srcdir}/gdb/gdbtk ; then
5636       GDB_TK="${gdb_tk}"
5637     else
5638       GDB_TK=""
5639     fi
5640     ;;
5641 esac
5642 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5643 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5644
5645 # Strip out unwanted targets.
5646
5647 # While at that, we remove Makefiles if we were started for recursive
5648 # configuration, so that the top-level Makefile reconfigures them,
5649 # like we used to do when configure itself was recursive.
5650
5651 # Loop over modules.  $extrasub must be used with care, limiting as
5652 # much as possible the usage of range addresses.  That's because autoconf
5653 # splits the sed script to overcome limits in the number of commands,
5654 # and relying on carefully-timed sed passes may turn out to be very hard
5655 # to maintain later.  In this particular case, you just have to be careful
5656 # not to nest @if/@endif pairs, because configure will not warn you at all.
5657
5658 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5659 if test "${enable_bootstrap+set}" = set; then
5660   enableval="$enable_bootstrap"
5661
5662 else
5663   enable_bootstrap=default
5664 fi;
5665
5666 # Issue errors and warnings for invalid/strange bootstrap combinations.
5667 case "$configdirs" in
5668   *gcc*) have_compiler=yes ;;
5669   *) have_compiler=no ;;
5670 esac
5671
5672 case "$have_compiler:$host:$target:$enable_bootstrap" in
5673   *:*:*:no) ;;
5674
5675   # Default behavior.  Enable bootstrap if we have a compiler
5676   # and we are in a native configuration.
5677   yes:$build:$build:default)
5678     enable_bootstrap=yes ;;
5679
5680   *:*:*:default)
5681     enable_bootstrap=no ;;
5682
5683   # We have a compiler and we are in a native configuration, bootstrap is ok
5684   yes:$build:$build:yes)
5685     ;;
5686
5687   # Other configurations, but we have a compiler.  Assume the user knows
5688   # what he's doing.
5689   yes:*:*:yes)
5690     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5691 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5692     ;;
5693
5694   # No compiler: if they passed --enable-bootstrap explicitly, fail
5695   no:*:*:yes)
5696     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5697 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5698    { (exit 1); exit 1; }; } ;;
5699
5700   # Fail if wrong command line
5701   *)
5702     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5703 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5704    { (exit 1); exit 1; }; }
5705     ;;
5706 esac
5707
5708 # Adjust the toplevel makefile according to whether bootstrap was selected.
5709 case "$enable_bootstrap" in
5710   yes)
5711     bootstrap_suffix=bootstrap ;;
5712   no)
5713     bootstrap_suffix=no-bootstrap ;;
5714 esac
5715
5716 for module in ${build_configdirs} ; do
5717   if test -z "${no_recursion}" \
5718      && test -f ${build_subdir}/${module}/Makefile; then
5719     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5720     rm -f ${build_subdir}/${module}/Makefile
5721   fi
5722   extrasub="$extrasub
5723 /^@if build-$module\$/d
5724 /^@endif build-$module\$/d
5725 /^@if build-$module-$bootstrap_suffix\$/d
5726 /^@endif build-$module-$bootstrap_suffix\$/d"
5727 done
5728 for module in ${configdirs} ; do
5729   if test -z "${no_recursion}"; then
5730     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5731       if test -f ${file}; then
5732         echo 1>&2 "*** removing ${file} to force reconfigure"
5733         rm -f ${file}
5734       fi
5735     done
5736   fi
5737   extrasub="$extrasub
5738 /^@if $module\$/d
5739 /^@endif $module\$/d
5740 /^@if $module-$bootstrap_suffix\$/d
5741 /^@endif $module-$bootstrap_suffix\$/d"
5742 done
5743 for module in ${target_configdirs} ; do
5744   if test -z "${no_recursion}" \
5745      && test -f ${target_subdir}/${module}/Makefile; then
5746     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5747     rm -f ${target_subdir}/${module}/Makefile
5748   fi
5749   extrasub="$extrasub
5750 /^@if target-$module\$/d
5751 /^@endif target-$module\$/d
5752 /^@if target-$module-$bootstrap_suffix\$/d
5753 /^@endif target-$module-$bootstrap_suffix\$/d"
5754 done
5755
5756 extrasub="$extrasub
5757 /^@if /,/^@endif /d"
5758
5759 # Create the serialization dependencies.  This uses a temporary file.
5760
5761 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5762 if test "${enable_serial_configure+set}" = set; then
5763   enableval="$enable_serial_configure"
5764
5765 fi;
5766
5767 case ${enable_serial_configure} in
5768   yes)
5769     enable_serial_build_configure=yes
5770     enable_serial_host_configure=yes
5771     enable_serial_target_configure=yes
5772     ;;
5773 esac
5774
5775 # These force 'configure's to be done one at a time, to avoid problems
5776 # with contention over a shared config.cache.
5777 rm -f serdep.tmp
5778 echo '# serdep.tmp' > serdep.tmp
5779 olditem=
5780 test "x${enable_serial_build_configure}" = xyes &&
5781 for item in ${build_configdirs} ; do
5782   case ${olditem} in
5783     "") ;;
5784     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5785   esac
5786   olditem=${item}
5787 done
5788 olditem=
5789 test "x${enable_serial_host_configure}" = xyes &&
5790 for item in ${configdirs} ; do
5791   case ${olditem} in
5792     "") ;;
5793     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5794   esac
5795   olditem=${item}
5796 done
5797 olditem=
5798 test "x${enable_serial_target_configure}" = xyes &&
5799 for item in ${target_configdirs} ; do
5800   case ${olditem} in
5801     "") ;;
5802     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5803   esac
5804   olditem=${item}
5805 done
5806 serialization_dependencies=serdep.tmp
5807
5808
5809 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5810 # target, nonopt, and variable assignments.  These are the ones we
5811 # might not want to pass down to subconfigures.  Also strip
5812 # program-prefix, program-suffix, and program-transform-name, so that
5813 # we can pass down a consistent program-transform-name.
5814 baseargs=
5815 keep_next=no
5816 skip_next=no
5817 eval "set -- $ac_configure_args"
5818 for ac_arg
5819 do
5820   if test X"$skip_next" = X"yes"; then
5821     skip_next=no
5822     continue
5823   fi
5824   if test X"$keep_next" = X"yes"; then
5825     case $ac_arg in
5826       *\'*)
5827         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5828     esac
5829     baseargs="$baseargs '$ac_arg'"
5830     keep_next=no
5831     continue
5832   fi
5833
5834   # Handle separated arguments.  Based on the logic generated by
5835   # autoconf 2.59.
5836   case $ac_arg in
5837     *=* | --config-cache | -C | -disable-* | --disable-* \
5838       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5839       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5840       | -with-* | --with-* | -without-* | --without-* | --x)
5841       separate_arg=no
5842       ;;
5843     -*)
5844       separate_arg=yes
5845       ;;
5846     *)
5847       separate_arg=no
5848       ;;
5849   esac
5850
5851   case "$ac_arg" in
5852     --no*)
5853       continue
5854       ;;
5855     --c* | \
5856     --sr* | \
5857     --ho* | \
5858     --bu* | \
5859     --t* | \
5860     --program-* | \
5861     -cache_file* | \
5862     -srcdir* | \
5863     -host* | \
5864     -build* | \
5865     -target* | \
5866     -program-prefix* | \
5867     -program-suffix* | \
5868     -program-transform-name* )
5869       skip_next=$separate_arg
5870       continue
5871       ;;
5872     -*)
5873       # An option.  Add it.
5874       case $ac_arg in
5875         *\'*)
5876           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5877       esac
5878       baseargs="$baseargs '$ac_arg'"
5879       keep_next=$separate_arg
5880       ;;
5881     *)
5882       # Either a variable assignment, or a nonopt (triplet).  Don't
5883       # pass it down; let the Makefile handle this.
5884       continue
5885       ;;
5886   esac
5887 done
5888 # Remove the initial space we just introduced and, as these will be
5889 # expanded by make, quote '$'.
5890 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5891
5892 # Add in --program-transform-name, after --program-prefix and
5893 # --program-suffix have been applied to it.  Autoconf has already
5894 # doubled dollar signs and backslashes in program_transform_name; we want
5895 # the backslashes un-doubled, and then the entire thing wrapped in single
5896 # quotes, because this will be expanded first by make and then by the shell.
5897 # Also, because we want to override the logic in subdir configure scripts to
5898 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5899 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5900 ${program_transform_name}
5901 EOF_SED
5902 gcc_transform_name=`cat conftestsed.out`
5903 rm -f conftestsed.out
5904 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5905 if test "$silent" = yes; then
5906   baseargs="$baseargs --silent"
5907 fi
5908
5909 # For the build-side libraries, we just need to pretend we're native,
5910 # and not use the same cache file.  Multilibs are neither needed nor
5911 # desired.
5912 build_configargs="--cache-file=../config.cache ${baseargs}"
5913
5914 # For host modules, accept cache file option, or specification as blank.
5915 case "${cache_file}" in
5916 "") # empty
5917   cache_file_option="" ;;
5918 /* | [A-Za-z]:[\\/]* ) # absolute path
5919   cache_file_option="--cache-file=${cache_file}" ;;
5920 *) # relative path
5921   cache_file_option="--cache-file=../${cache_file}" ;;
5922 esac
5923
5924 # Host dirs don't like to share a cache file either, horribly enough.
5925 # This seems to be due to autoconf 2.5x stupidity.
5926 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5927
5928 target_configargs=${baseargs}
5929
5930 # Passing a --with-cross-host argument lets the target libraries know
5931 # whether they are being built with a cross-compiler or being built
5932 # native.  However, it would be better to use other mechanisms to make the
5933 # sorts of decisions they want to make on this basis.  Please consider
5934 # this option to be deprecated.  FIXME.
5935 if test x${is_cross_compiler} = xyes ; then
5936   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5937 fi
5938
5939 # Default to --enable-multilib.
5940 if test x${enable_multilib} = x ; then
5941   target_configargs="--enable-multilib ${target_configargs}"
5942 fi
5943
5944 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5945 # changed from the earlier setting of with_newlib.
5946 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5947   target_configargs="--with-newlib ${target_configargs}"
5948 fi
5949
5950 # Different target subdirs use different values of certain variables
5951 # (notably CXX).  Worse, multilibs use *lots* of different values.
5952 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5953 # it doesn't automatically accept command-line overrides of them.
5954 # This means it's not safe for target subdirs to share a cache file,
5955 # which is disgusting, but there you have it.  Hopefully this can be
5956 # fixed in future.  It's still worthwhile to use a cache file for each
5957 # directory.  I think.
5958
5959 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5960 # We need to pass --target, as newer autoconf's requires consistency
5961 # for target_alias and gcc doesn't manage it consistently.
5962 target_configargs="--cache-file=./config.cache ${target_configargs}"
5963
5964 FLAGS_FOR_TARGET=
5965 case " $target_configdirs " in
5966  *" newlib "*)
5967   case " $target_configargs " in
5968   *" --with-newlib "*)
5969    case "$target" in
5970    *-cygwin*)
5971      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' ;;
5972    esac
5973
5974    # If we're not building GCC, don't discard standard headers.
5975    if test -d ${srcdir}/gcc; then
5976      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5977
5978      if test "${build}" != "${host}"; then
5979        # On Canadian crosses, CC_FOR_TARGET will have already been set
5980        # by `configure', so we won't have an opportunity to add -Bgcc/
5981        # to it.  This is right: we don't want to search that directory
5982        # for binaries, but we want the header files in there, so add
5983        # them explicitly.
5984        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5985
5986        # Someone might think of using the pre-installed headers on
5987        # Canadian crosses, in case the installed compiler is not fully
5988        # compatible with the compiler being built.  In this case, it
5989        # would be better to flag an error than risking having
5990        # incompatible object files being constructed.  We can't
5991        # guarantee that an error will be flagged, but let's hope the
5992        # compiler will do it, when presented with incompatible header
5993        # files.
5994      fi
5995    fi
5996
5997    case "${target}-${is_cross_compiler}" in
5998    i[3456789]86-*-linux*-no)
5999       # Here host == target, so we don't need to build gcc,
6000       # so we don't want to discard standard headers.
6001       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6002       ;;
6003    *)
6004       # If we're building newlib, use its generic headers last, but search
6005       # for any libc-related directories first (so make it the last -B
6006       # switch).
6007       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6008
6009       # If we're building libgloss, find the startup file, simulator library
6010       # and linker script.
6011       case " $target_configdirs " in
6012         *" libgloss "*)
6013         # Look for startup file, simulator library and maybe linker script.
6014         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6015         # Look for libnosys.a in case the target needs it.
6016         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6017         # Most targets have the linker script in the source directory.
6018         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6019         ;;
6020       esac
6021       ;;
6022    esac
6023    ;;
6024   esac
6025   ;;
6026 esac
6027 case "$target" in
6028 *-mingw*)
6029   # Can't be handled as Cygwin above since Mingw does not use newlib.
6030   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' ;;
6031 esac
6032
6033 # Allow the user to override the flags for
6034 # our build compiler if desired.
6035 if test x"${build}" = x"${host}" ; then
6036   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6037   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6038   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6039 fi
6040
6041 # On Canadian crosses, we'll be searching the right directories for
6042 # the previously-installed cross compiler, so don't bother to add
6043 # flags for directories within the install tree of the compiler
6044 # being built; programs in there won't even run.
6045 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6046   # Search for pre-installed headers if nothing else fits.
6047   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6048 fi
6049
6050 if test "x${use_gnu_ld}" = x &&
6051    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6052   # Arrange for us to find uninstalled linker scripts.
6053   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6054 fi
6055
6056 # Search for other target-specific linker scripts and such.
6057 case "${target}" in
6058   mep*)
6059     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6060     ;;
6061 esac
6062
6063 # Makefile fragments.
6064 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6065 do
6066   eval fragval=\$$frag
6067   if test $fragval != /dev/null; then
6068     eval $frag=${srcdir}/$fragval
6069   fi
6070 done
6071
6072
6073
6074
6075
6076 # Miscellanea: directories, flags, etc.
6077
6078
6079
6080
6081
6082
6083
6084
6085 # Build module lists & subconfigure args.
6086
6087
6088
6089 # Host module lists & subconfigure args.
6090
6091
6092
6093 # Target module lists & subconfigure args.
6094
6095
6096
6097 # Build tools.
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115 # Generate default definitions for YACC, M4, LEX and other programs that run
6116 # on the build machine.  These are used if the Makefile can't locate these
6117 # programs in objdir.
6118 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6119
6120 for ac_prog in 'bison -y' byacc yacc
6121 do
6122   # Extract the first word of "$ac_prog", so it can be a program name with args.
6123 set dummy $ac_prog; ac_word=$2
6124 echo "$as_me:$LINENO: checking for $ac_word" >&5
6125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6126 if test "${ac_cv_prog_YACC+set}" = set; then
6127   echo $ECHO_N "(cached) $ECHO_C" >&6
6128 else
6129   if test -n "$YACC"; then
6130   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6131 else
6132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6133 for as_dir in $PATH
6134 do
6135   IFS=$as_save_IFS
6136   test -z "$as_dir" && as_dir=.
6137   for ac_exec_ext in '' $ac_executable_extensions; do
6138   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6139     ac_cv_prog_YACC="$ac_prog"
6140     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6141     break 2
6142   fi
6143 done
6144 done
6145
6146 fi
6147 fi
6148 YACC=$ac_cv_prog_YACC
6149 if test -n "$YACC"; then
6150   echo "$as_me:$LINENO: result: $YACC" >&5
6151 echo "${ECHO_T}$YACC" >&6
6152 else
6153   echo "$as_me:$LINENO: result: no" >&5
6154 echo "${ECHO_T}no" >&6
6155 fi
6156
6157   test -n "$YACC" && break
6158 done
6159 test -n "$YACC" || YACC="$MISSING bison -y"
6160
6161 case " $build_configdirs " in
6162   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6163   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6164 esac
6165
6166 for ac_prog in bison
6167 do
6168   # Extract the first word of "$ac_prog", so it can be a program name with args.
6169 set dummy $ac_prog; ac_word=$2
6170 echo "$as_me:$LINENO: checking for $ac_word" >&5
6171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6172 if test "${ac_cv_prog_BISON+set}" = set; then
6173   echo $ECHO_N "(cached) $ECHO_C" >&6
6174 else
6175   if test -n "$BISON"; then
6176   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6177 else
6178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6179 for as_dir in $PATH
6180 do
6181   IFS=$as_save_IFS
6182   test -z "$as_dir" && as_dir=.
6183   for ac_exec_ext in '' $ac_executable_extensions; do
6184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6185     ac_cv_prog_BISON="$ac_prog"
6186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6187     break 2
6188   fi
6189 done
6190 done
6191
6192 fi
6193 fi
6194 BISON=$ac_cv_prog_BISON
6195 if test -n "$BISON"; then
6196   echo "$as_me:$LINENO: result: $BISON" >&5
6197 echo "${ECHO_T}$BISON" >&6
6198 else
6199   echo "$as_me:$LINENO: result: no" >&5
6200 echo "${ECHO_T}no" >&6
6201 fi
6202
6203   test -n "$BISON" && break
6204 done
6205 test -n "$BISON" || BISON="$MISSING bison"
6206
6207 case " $build_configdirs " in
6208   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6209 esac
6210
6211 for ac_prog in gm4 gnum4 m4
6212 do
6213   # Extract the first word of "$ac_prog", so it can be a program name with args.
6214 set dummy $ac_prog; ac_word=$2
6215 echo "$as_me:$LINENO: checking for $ac_word" >&5
6216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6217 if test "${ac_cv_prog_M4+set}" = set; then
6218   echo $ECHO_N "(cached) $ECHO_C" >&6
6219 else
6220   if test -n "$M4"; then
6221   ac_cv_prog_M4="$M4" # Let the user override the test.
6222 else
6223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6224 for as_dir in $PATH
6225 do
6226   IFS=$as_save_IFS
6227   test -z "$as_dir" && as_dir=.
6228   for ac_exec_ext in '' $ac_executable_extensions; do
6229   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6230     ac_cv_prog_M4="$ac_prog"
6231     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6232     break 2
6233   fi
6234 done
6235 done
6236
6237 fi
6238 fi
6239 M4=$ac_cv_prog_M4
6240 if test -n "$M4"; then
6241   echo "$as_me:$LINENO: result: $M4" >&5
6242 echo "${ECHO_T}$M4" >&6
6243 else
6244   echo "$as_me:$LINENO: result: no" >&5
6245 echo "${ECHO_T}no" >&6
6246 fi
6247
6248   test -n "$M4" && break
6249 done
6250 test -n "$M4" || M4="$MISSING m4"
6251
6252 case " $build_configdirs " in
6253   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6254 esac
6255
6256 for ac_prog in flex lex
6257 do
6258   # Extract the first word of "$ac_prog", so it can be a program name with args.
6259 set dummy $ac_prog; ac_word=$2
6260 echo "$as_me:$LINENO: checking for $ac_word" >&5
6261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6262 if test "${ac_cv_prog_LEX+set}" = set; then
6263   echo $ECHO_N "(cached) $ECHO_C" >&6
6264 else
6265   if test -n "$LEX"; then
6266   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6267 else
6268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6269 for as_dir in $PATH
6270 do
6271   IFS=$as_save_IFS
6272   test -z "$as_dir" && as_dir=.
6273   for ac_exec_ext in '' $ac_executable_extensions; do
6274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6275     ac_cv_prog_LEX="$ac_prog"
6276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6277     break 2
6278   fi
6279 done
6280 done
6281
6282 fi
6283 fi
6284 LEX=$ac_cv_prog_LEX
6285 if test -n "$LEX"; then
6286   echo "$as_me:$LINENO: result: $LEX" >&5
6287 echo "${ECHO_T}$LEX" >&6
6288 else
6289   echo "$as_me:$LINENO: result: no" >&5
6290 echo "${ECHO_T}no" >&6
6291 fi
6292
6293   test -n "$LEX" && break
6294 done
6295 test -n "$LEX" || LEX="$MISSING flex"
6296
6297 case " $build_configdirs " in
6298   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6299   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6300 esac
6301
6302 for ac_prog in flex
6303 do
6304   # Extract the first word of "$ac_prog", so it can be a program name with args.
6305 set dummy $ac_prog; ac_word=$2
6306 echo "$as_me:$LINENO: checking for $ac_word" >&5
6307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6308 if test "${ac_cv_prog_FLEX+set}" = set; then
6309   echo $ECHO_N "(cached) $ECHO_C" >&6
6310 else
6311   if test -n "$FLEX"; then
6312   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6313 else
6314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6315 for as_dir in $PATH
6316 do
6317   IFS=$as_save_IFS
6318   test -z "$as_dir" && as_dir=.
6319   for ac_exec_ext in '' $ac_executable_extensions; do
6320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6321     ac_cv_prog_FLEX="$ac_prog"
6322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6323     break 2
6324   fi
6325 done
6326 done
6327
6328 fi
6329 fi
6330 FLEX=$ac_cv_prog_FLEX
6331 if test -n "$FLEX"; then
6332   echo "$as_me:$LINENO: result: $FLEX" >&5
6333 echo "${ECHO_T}$FLEX" >&6
6334 else
6335   echo "$as_me:$LINENO: result: no" >&5
6336 echo "${ECHO_T}no" >&6
6337 fi
6338
6339   test -n "$FLEX" && break
6340 done
6341 test -n "$FLEX" || FLEX="$MISSING flex"
6342
6343 case " $build_configdirs " in
6344   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6345 esac
6346
6347 for ac_prog in makeinfo
6348 do
6349   # Extract the first word of "$ac_prog", so it can be a program name with args.
6350 set dummy $ac_prog; ac_word=$2
6351 echo "$as_me:$LINENO: checking for $ac_word" >&5
6352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6353 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6354   echo $ECHO_N "(cached) $ECHO_C" >&6
6355 else
6356   if test -n "$MAKEINFO"; then
6357   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6358 else
6359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6360 for as_dir in $PATH
6361 do
6362   IFS=$as_save_IFS
6363   test -z "$as_dir" && as_dir=.
6364   for ac_exec_ext in '' $ac_executable_extensions; do
6365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6366     ac_cv_prog_MAKEINFO="$ac_prog"
6367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6368     break 2
6369   fi
6370 done
6371 done
6372
6373 fi
6374 fi
6375 MAKEINFO=$ac_cv_prog_MAKEINFO
6376 if test -n "$MAKEINFO"; then
6377   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6378 echo "${ECHO_T}$MAKEINFO" >&6
6379 else
6380   echo "$as_me:$LINENO: result: no" >&5
6381 echo "${ECHO_T}no" >&6
6382 fi
6383
6384   test -n "$MAKEINFO" && break
6385 done
6386 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6387
6388 case " $build_configdirs " in
6389   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6390   *)
6391
6392     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6393     # higher, else we use the "missing" dummy.
6394     if ${MAKEINFO} --version \
6395        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6396       :
6397     else
6398       MAKEINFO="$MISSING makeinfo"
6399     fi
6400     ;;
6401
6402 esac
6403
6404 # FIXME: expect and dejagnu may become build tools?
6405
6406 for ac_prog in expect
6407 do
6408   # Extract the first word of "$ac_prog", so it can be a program name with args.
6409 set dummy $ac_prog; ac_word=$2
6410 echo "$as_me:$LINENO: checking for $ac_word" >&5
6411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6412 if test "${ac_cv_prog_EXPECT+set}" = set; then
6413   echo $ECHO_N "(cached) $ECHO_C" >&6
6414 else
6415   if test -n "$EXPECT"; then
6416   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6417 else
6418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6419 for as_dir in $PATH
6420 do
6421   IFS=$as_save_IFS
6422   test -z "$as_dir" && as_dir=.
6423   for ac_exec_ext in '' $ac_executable_extensions; do
6424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6425     ac_cv_prog_EXPECT="$ac_prog"
6426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6427     break 2
6428   fi
6429 done
6430 done
6431
6432 fi
6433 fi
6434 EXPECT=$ac_cv_prog_EXPECT
6435 if test -n "$EXPECT"; then
6436   echo "$as_me:$LINENO: result: $EXPECT" >&5
6437 echo "${ECHO_T}$EXPECT" >&6
6438 else
6439   echo "$as_me:$LINENO: result: no" >&5
6440 echo "${ECHO_T}no" >&6
6441 fi
6442
6443   test -n "$EXPECT" && break
6444 done
6445 test -n "$EXPECT" || EXPECT="expect"
6446
6447 case " $configdirs " in
6448   *" expect "*)
6449     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6450     ;;
6451 esac
6452
6453 for ac_prog in runtest
6454 do
6455   # Extract the first word of "$ac_prog", so it can be a program name with args.
6456 set dummy $ac_prog; ac_word=$2
6457 echo "$as_me:$LINENO: checking for $ac_word" >&5
6458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6459 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6460   echo $ECHO_N "(cached) $ECHO_C" >&6
6461 else
6462   if test -n "$RUNTEST"; then
6463   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6464 else
6465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6466 for as_dir in $PATH
6467 do
6468   IFS=$as_save_IFS
6469   test -z "$as_dir" && as_dir=.
6470   for ac_exec_ext in '' $ac_executable_extensions; do
6471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6472     ac_cv_prog_RUNTEST="$ac_prog"
6473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6474     break 2
6475   fi
6476 done
6477 done
6478
6479 fi
6480 fi
6481 RUNTEST=$ac_cv_prog_RUNTEST
6482 if test -n "$RUNTEST"; then
6483   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6484 echo "${ECHO_T}$RUNTEST" >&6
6485 else
6486   echo "$as_me:$LINENO: result: no" >&5
6487 echo "${ECHO_T}no" >&6
6488 fi
6489
6490   test -n "$RUNTEST" && break
6491 done
6492 test -n "$RUNTEST" || RUNTEST="runtest"
6493
6494 case " $configdirs " in
6495   *" dejagnu "*)
6496     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6497     ;;
6498 esac
6499
6500
6501 # Host tools.
6502 ncn_tool_prefix=
6503 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6504 ncn_target_tool_prefix=
6505 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6506
6507
6508
6509 if test -n "$AR"; then
6510   ac_cv_prog_AR=$AR
6511 elif test -n "$ac_cv_prog_AR"; then
6512   AR=$ac_cv_prog_AR
6513 fi
6514
6515 if test -n "$ac_cv_prog_AR"; then
6516   for ncn_progname in ar; do
6517     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6518 set dummy ${ncn_progname}; ac_word=$2
6519 echo "$as_me:$LINENO: checking for $ac_word" >&5
6520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6521 if test "${ac_cv_prog_AR+set}" = set; then
6522   echo $ECHO_N "(cached) $ECHO_C" >&6
6523 else
6524   if test -n "$AR"; then
6525   ac_cv_prog_AR="$AR" # Let the user override the test.
6526 else
6527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6528 for as_dir in $PATH
6529 do
6530   IFS=$as_save_IFS
6531   test -z "$as_dir" && as_dir=.
6532   for ac_exec_ext in '' $ac_executable_extensions; do
6533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6534     ac_cv_prog_AR="${ncn_progname}"
6535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6536     break 2
6537   fi
6538 done
6539 done
6540
6541 fi
6542 fi
6543 AR=$ac_cv_prog_AR
6544 if test -n "$AR"; then
6545   echo "$as_me:$LINENO: result: $AR" >&5
6546 echo "${ECHO_T}$AR" >&6
6547 else
6548   echo "$as_me:$LINENO: result: no" >&5
6549 echo "${ECHO_T}no" >&6
6550 fi
6551
6552   done
6553 fi
6554
6555 for ncn_progname in ar; do
6556   if test -n "$ncn_tool_prefix"; then
6557     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6558 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6559 echo "$as_me:$LINENO: checking for $ac_word" >&5
6560 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6561 if test "${ac_cv_prog_AR+set}" = set; then
6562   echo $ECHO_N "(cached) $ECHO_C" >&6
6563 else
6564   if test -n "$AR"; then
6565   ac_cv_prog_AR="$AR" # Let the user override the test.
6566 else
6567 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6568 for as_dir in $PATH
6569 do
6570   IFS=$as_save_IFS
6571   test -z "$as_dir" && as_dir=.
6572   for ac_exec_ext in '' $ac_executable_extensions; do
6573   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6574     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6575     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6576     break 2
6577   fi
6578 done
6579 done
6580
6581 fi
6582 fi
6583 AR=$ac_cv_prog_AR
6584 if test -n "$AR"; then
6585   echo "$as_me:$LINENO: result: $AR" >&5
6586 echo "${ECHO_T}$AR" >&6
6587 else
6588   echo "$as_me:$LINENO: result: no" >&5
6589 echo "${ECHO_T}no" >&6
6590 fi
6591
6592   fi
6593   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6594     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6595 set dummy ${ncn_progname}; ac_word=$2
6596 echo "$as_me:$LINENO: checking for $ac_word" >&5
6597 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6598 if test "${ac_cv_prog_AR+set}" = set; then
6599   echo $ECHO_N "(cached) $ECHO_C" >&6
6600 else
6601   if test -n "$AR"; then
6602   ac_cv_prog_AR="$AR" # Let the user override the test.
6603 else
6604 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6605 for as_dir in $PATH
6606 do
6607   IFS=$as_save_IFS
6608   test -z "$as_dir" && as_dir=.
6609   for ac_exec_ext in '' $ac_executable_extensions; do
6610   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6611     ac_cv_prog_AR="${ncn_progname}"
6612     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6613     break 2
6614   fi
6615 done
6616 done
6617
6618 fi
6619 fi
6620 AR=$ac_cv_prog_AR
6621 if test -n "$AR"; then
6622   echo "$as_me:$LINENO: result: $AR" >&5
6623 echo "${ECHO_T}$AR" >&6
6624 else
6625   echo "$as_me:$LINENO: result: no" >&5
6626 echo "${ECHO_T}no" >&6
6627 fi
6628
6629   fi
6630   test -n "$ac_cv_prog_AR" && break
6631 done
6632
6633 if test -z "$ac_cv_prog_AR" ; then
6634   set dummy ar
6635   if test $build = $host ; then
6636     AR="$2"
6637   else
6638     AR="${ncn_tool_prefix}$2"
6639   fi
6640 fi
6641
6642
6643
6644 if test -n "$AS"; then
6645   ac_cv_prog_AS=$AS
6646 elif test -n "$ac_cv_prog_AS"; then
6647   AS=$ac_cv_prog_AS
6648 fi
6649
6650 if test -n "$ac_cv_prog_AS"; then
6651   for ncn_progname in as; do
6652     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6653 set dummy ${ncn_progname}; ac_word=$2
6654 echo "$as_me:$LINENO: checking for $ac_word" >&5
6655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6656 if test "${ac_cv_prog_AS+set}" = set; then
6657   echo $ECHO_N "(cached) $ECHO_C" >&6
6658 else
6659   if test -n "$AS"; then
6660   ac_cv_prog_AS="$AS" # Let the user override the test.
6661 else
6662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6663 for as_dir in $PATH
6664 do
6665   IFS=$as_save_IFS
6666   test -z "$as_dir" && as_dir=.
6667   for ac_exec_ext in '' $ac_executable_extensions; do
6668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6669     ac_cv_prog_AS="${ncn_progname}"
6670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6671     break 2
6672   fi
6673 done
6674 done
6675
6676 fi
6677 fi
6678 AS=$ac_cv_prog_AS
6679 if test -n "$AS"; then
6680   echo "$as_me:$LINENO: result: $AS" >&5
6681 echo "${ECHO_T}$AS" >&6
6682 else
6683   echo "$as_me:$LINENO: result: no" >&5
6684 echo "${ECHO_T}no" >&6
6685 fi
6686
6687   done
6688 fi
6689
6690 for ncn_progname in as; do
6691   if test -n "$ncn_tool_prefix"; then
6692     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6693 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6694 echo "$as_me:$LINENO: checking for $ac_word" >&5
6695 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6696 if test "${ac_cv_prog_AS+set}" = set; then
6697   echo $ECHO_N "(cached) $ECHO_C" >&6
6698 else
6699   if test -n "$AS"; then
6700   ac_cv_prog_AS="$AS" # Let the user override the test.
6701 else
6702 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6703 for as_dir in $PATH
6704 do
6705   IFS=$as_save_IFS
6706   test -z "$as_dir" && as_dir=.
6707   for ac_exec_ext in '' $ac_executable_extensions; do
6708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6709     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6711     break 2
6712   fi
6713 done
6714 done
6715
6716 fi
6717 fi
6718 AS=$ac_cv_prog_AS
6719 if test -n "$AS"; then
6720   echo "$as_me:$LINENO: result: $AS" >&5
6721 echo "${ECHO_T}$AS" >&6
6722 else
6723   echo "$as_me:$LINENO: result: no" >&5
6724 echo "${ECHO_T}no" >&6
6725 fi
6726
6727   fi
6728   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6729     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6730 set dummy ${ncn_progname}; ac_word=$2
6731 echo "$as_me:$LINENO: checking for $ac_word" >&5
6732 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6733 if test "${ac_cv_prog_AS+set}" = set; then
6734   echo $ECHO_N "(cached) $ECHO_C" >&6
6735 else
6736   if test -n "$AS"; then
6737   ac_cv_prog_AS="$AS" # Let the user override the test.
6738 else
6739 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6740 for as_dir in $PATH
6741 do
6742   IFS=$as_save_IFS
6743   test -z "$as_dir" && as_dir=.
6744   for ac_exec_ext in '' $ac_executable_extensions; do
6745   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6746     ac_cv_prog_AS="${ncn_progname}"
6747     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6748     break 2
6749   fi
6750 done
6751 done
6752
6753 fi
6754 fi
6755 AS=$ac_cv_prog_AS
6756 if test -n "$AS"; then
6757   echo "$as_me:$LINENO: result: $AS" >&5
6758 echo "${ECHO_T}$AS" >&6
6759 else
6760   echo "$as_me:$LINENO: result: no" >&5
6761 echo "${ECHO_T}no" >&6
6762 fi
6763
6764   fi
6765   test -n "$ac_cv_prog_AS" && break
6766 done
6767
6768 if test -z "$ac_cv_prog_AS" ; then
6769   set dummy as
6770   if test $build = $host ; then
6771     AS="$2"
6772   else
6773     AS="${ncn_tool_prefix}$2"
6774   fi
6775 fi
6776
6777
6778
6779 if test -n "$DLLTOOL"; then
6780   ac_cv_prog_DLLTOOL=$DLLTOOL
6781 elif test -n "$ac_cv_prog_DLLTOOL"; then
6782   DLLTOOL=$ac_cv_prog_DLLTOOL
6783 fi
6784
6785 if test -n "$ac_cv_prog_DLLTOOL"; then
6786   for ncn_progname in dlltool; do
6787     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6788 set dummy ${ncn_progname}; ac_word=$2
6789 echo "$as_me:$LINENO: checking for $ac_word" >&5
6790 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6791 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6792   echo $ECHO_N "(cached) $ECHO_C" >&6
6793 else
6794   if test -n "$DLLTOOL"; then
6795   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6796 else
6797 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6798 for as_dir in $PATH
6799 do
6800   IFS=$as_save_IFS
6801   test -z "$as_dir" && as_dir=.
6802   for ac_exec_ext in '' $ac_executable_extensions; do
6803   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6804     ac_cv_prog_DLLTOOL="${ncn_progname}"
6805     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6806     break 2
6807   fi
6808 done
6809 done
6810
6811 fi
6812 fi
6813 DLLTOOL=$ac_cv_prog_DLLTOOL
6814 if test -n "$DLLTOOL"; then
6815   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6816 echo "${ECHO_T}$DLLTOOL" >&6
6817 else
6818   echo "$as_me:$LINENO: result: no" >&5
6819 echo "${ECHO_T}no" >&6
6820 fi
6821
6822   done
6823 fi
6824
6825 for ncn_progname in dlltool; do
6826   if test -n "$ncn_tool_prefix"; then
6827     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6828 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6829 echo "$as_me:$LINENO: checking for $ac_word" >&5
6830 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6831 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6832   echo $ECHO_N "(cached) $ECHO_C" >&6
6833 else
6834   if test -n "$DLLTOOL"; then
6835   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6836 else
6837 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6838 for as_dir in $PATH
6839 do
6840   IFS=$as_save_IFS
6841   test -z "$as_dir" && as_dir=.
6842   for ac_exec_ext in '' $ac_executable_extensions; do
6843   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6844     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6845     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6846     break 2
6847   fi
6848 done
6849 done
6850
6851 fi
6852 fi
6853 DLLTOOL=$ac_cv_prog_DLLTOOL
6854 if test -n "$DLLTOOL"; then
6855   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6856 echo "${ECHO_T}$DLLTOOL" >&6
6857 else
6858   echo "$as_me:$LINENO: result: no" >&5
6859 echo "${ECHO_T}no" >&6
6860 fi
6861
6862   fi
6863   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6864     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6865 set dummy ${ncn_progname}; ac_word=$2
6866 echo "$as_me:$LINENO: checking for $ac_word" >&5
6867 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6868 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6869   echo $ECHO_N "(cached) $ECHO_C" >&6
6870 else
6871   if test -n "$DLLTOOL"; then
6872   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6873 else
6874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6875 for as_dir in $PATH
6876 do
6877   IFS=$as_save_IFS
6878   test -z "$as_dir" && as_dir=.
6879   for ac_exec_ext in '' $ac_executable_extensions; do
6880   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6881     ac_cv_prog_DLLTOOL="${ncn_progname}"
6882     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6883     break 2
6884   fi
6885 done
6886 done
6887
6888 fi
6889 fi
6890 DLLTOOL=$ac_cv_prog_DLLTOOL
6891 if test -n "$DLLTOOL"; then
6892   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6893 echo "${ECHO_T}$DLLTOOL" >&6
6894 else
6895   echo "$as_me:$LINENO: result: no" >&5
6896 echo "${ECHO_T}no" >&6
6897 fi
6898
6899   fi
6900   test -n "$ac_cv_prog_DLLTOOL" && break
6901 done
6902
6903 if test -z "$ac_cv_prog_DLLTOOL" ; then
6904   set dummy dlltool
6905   if test $build = $host ; then
6906     DLLTOOL="$2"
6907   else
6908     DLLTOOL="${ncn_tool_prefix}$2"
6909   fi
6910 fi
6911
6912
6913
6914 if test -n "$LD"; then
6915   ac_cv_prog_LD=$LD
6916 elif test -n "$ac_cv_prog_LD"; then
6917   LD=$ac_cv_prog_LD
6918 fi
6919
6920 if test -n "$ac_cv_prog_LD"; then
6921   for ncn_progname in ld; do
6922     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6923 set dummy ${ncn_progname}; ac_word=$2
6924 echo "$as_me:$LINENO: checking for $ac_word" >&5
6925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6926 if test "${ac_cv_prog_LD+set}" = set; then
6927   echo $ECHO_N "(cached) $ECHO_C" >&6
6928 else
6929   if test -n "$LD"; then
6930   ac_cv_prog_LD="$LD" # Let the user override the test.
6931 else
6932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6933 for as_dir in $PATH
6934 do
6935   IFS=$as_save_IFS
6936   test -z "$as_dir" && as_dir=.
6937   for ac_exec_ext in '' $ac_executable_extensions; do
6938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6939     ac_cv_prog_LD="${ncn_progname}"
6940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6941     break 2
6942   fi
6943 done
6944 done
6945
6946 fi
6947 fi
6948 LD=$ac_cv_prog_LD
6949 if test -n "$LD"; then
6950   echo "$as_me:$LINENO: result: $LD" >&5
6951 echo "${ECHO_T}$LD" >&6
6952 else
6953   echo "$as_me:$LINENO: result: no" >&5
6954 echo "${ECHO_T}no" >&6
6955 fi
6956
6957   done
6958 fi
6959
6960 for ncn_progname in ld; do
6961   if test -n "$ncn_tool_prefix"; then
6962     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6963 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6964 echo "$as_me:$LINENO: checking for $ac_word" >&5
6965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6966 if test "${ac_cv_prog_LD+set}" = set; then
6967   echo $ECHO_N "(cached) $ECHO_C" >&6
6968 else
6969   if test -n "$LD"; then
6970   ac_cv_prog_LD="$LD" # Let the user override the test.
6971 else
6972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6973 for as_dir in $PATH
6974 do
6975   IFS=$as_save_IFS
6976   test -z "$as_dir" && as_dir=.
6977   for ac_exec_ext in '' $ac_executable_extensions; do
6978   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6979     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6981     break 2
6982   fi
6983 done
6984 done
6985
6986 fi
6987 fi
6988 LD=$ac_cv_prog_LD
6989 if test -n "$LD"; then
6990   echo "$as_me:$LINENO: result: $LD" >&5
6991 echo "${ECHO_T}$LD" >&6
6992 else
6993   echo "$as_me:$LINENO: result: no" >&5
6994 echo "${ECHO_T}no" >&6
6995 fi
6996
6997   fi
6998   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6999     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7000 set dummy ${ncn_progname}; ac_word=$2
7001 echo "$as_me:$LINENO: checking for $ac_word" >&5
7002 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7003 if test "${ac_cv_prog_LD+set}" = set; then
7004   echo $ECHO_N "(cached) $ECHO_C" >&6
7005 else
7006   if test -n "$LD"; then
7007   ac_cv_prog_LD="$LD" # Let the user override the test.
7008 else
7009 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7010 for as_dir in $PATH
7011 do
7012   IFS=$as_save_IFS
7013   test -z "$as_dir" && as_dir=.
7014   for ac_exec_ext in '' $ac_executable_extensions; do
7015   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7016     ac_cv_prog_LD="${ncn_progname}"
7017     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7018     break 2
7019   fi
7020 done
7021 done
7022
7023 fi
7024 fi
7025 LD=$ac_cv_prog_LD
7026 if test -n "$LD"; then
7027   echo "$as_me:$LINENO: result: $LD" >&5
7028 echo "${ECHO_T}$LD" >&6
7029 else
7030   echo "$as_me:$LINENO: result: no" >&5
7031 echo "${ECHO_T}no" >&6
7032 fi
7033
7034   fi
7035   test -n "$ac_cv_prog_LD" && break
7036 done
7037
7038 if test -z "$ac_cv_prog_LD" ; then
7039   set dummy ld
7040   if test $build = $host ; then
7041     LD="$2"
7042   else
7043     LD="${ncn_tool_prefix}$2"
7044   fi
7045 fi
7046
7047
7048
7049 if test -n "$LIPO"; then
7050   ac_cv_prog_LIPO=$LIPO
7051 elif test -n "$ac_cv_prog_LIPO"; then
7052   LIPO=$ac_cv_prog_LIPO
7053 fi
7054
7055 if test -n "$ac_cv_prog_LIPO"; then
7056   for ncn_progname in lipo; do
7057     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7058 set dummy ${ncn_progname}; ac_word=$2
7059 echo "$as_me:$LINENO: checking for $ac_word" >&5
7060 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7061 if test "${ac_cv_prog_LIPO+set}" = set; then
7062   echo $ECHO_N "(cached) $ECHO_C" >&6
7063 else
7064   if test -n "$LIPO"; then
7065   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7066 else
7067 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7068 for as_dir in $PATH
7069 do
7070   IFS=$as_save_IFS
7071   test -z "$as_dir" && as_dir=.
7072   for ac_exec_ext in '' $ac_executable_extensions; do
7073   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7074     ac_cv_prog_LIPO="${ncn_progname}"
7075     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7076     break 2
7077   fi
7078 done
7079 done
7080
7081 fi
7082 fi
7083 LIPO=$ac_cv_prog_LIPO
7084 if test -n "$LIPO"; then
7085   echo "$as_me:$LINENO: result: $LIPO" >&5
7086 echo "${ECHO_T}$LIPO" >&6
7087 else
7088   echo "$as_me:$LINENO: result: no" >&5
7089 echo "${ECHO_T}no" >&6
7090 fi
7091
7092   done
7093 fi
7094
7095 for ncn_progname in lipo; do
7096   if test -n "$ncn_tool_prefix"; then
7097     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7098 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7099 echo "$as_me:$LINENO: checking for $ac_word" >&5
7100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7101 if test "${ac_cv_prog_LIPO+set}" = set; then
7102   echo $ECHO_N "(cached) $ECHO_C" >&6
7103 else
7104   if test -n "$LIPO"; then
7105   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7106 else
7107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7108 for as_dir in $PATH
7109 do
7110   IFS=$as_save_IFS
7111   test -z "$as_dir" && as_dir=.
7112   for ac_exec_ext in '' $ac_executable_extensions; do
7113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7114     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7116     break 2
7117   fi
7118 done
7119 done
7120
7121 fi
7122 fi
7123 LIPO=$ac_cv_prog_LIPO
7124 if test -n "$LIPO"; then
7125   echo "$as_me:$LINENO: result: $LIPO" >&5
7126 echo "${ECHO_T}$LIPO" >&6
7127 else
7128   echo "$as_me:$LINENO: result: no" >&5
7129 echo "${ECHO_T}no" >&6
7130 fi
7131
7132   fi
7133   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7134     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7135 set dummy ${ncn_progname}; ac_word=$2
7136 echo "$as_me:$LINENO: checking for $ac_word" >&5
7137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7138 if test "${ac_cv_prog_LIPO+set}" = set; then
7139   echo $ECHO_N "(cached) $ECHO_C" >&6
7140 else
7141   if test -n "$LIPO"; then
7142   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7143 else
7144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7145 for as_dir in $PATH
7146 do
7147   IFS=$as_save_IFS
7148   test -z "$as_dir" && as_dir=.
7149   for ac_exec_ext in '' $ac_executable_extensions; do
7150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7151     ac_cv_prog_LIPO="${ncn_progname}"
7152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7153     break 2
7154   fi
7155 done
7156 done
7157
7158 fi
7159 fi
7160 LIPO=$ac_cv_prog_LIPO
7161 if test -n "$LIPO"; then
7162   echo "$as_me:$LINENO: result: $LIPO" >&5
7163 echo "${ECHO_T}$LIPO" >&6
7164 else
7165   echo "$as_me:$LINENO: result: no" >&5
7166 echo "${ECHO_T}no" >&6
7167 fi
7168
7169   fi
7170   test -n "$ac_cv_prog_LIPO" && break
7171 done
7172
7173 if test -z "$ac_cv_prog_LIPO" ; then
7174   set dummy lipo
7175   if test $build = $host ; then
7176     LIPO="$2"
7177   else
7178     LIPO="${ncn_tool_prefix}$2"
7179   fi
7180 fi
7181
7182
7183
7184 if test -n "$NM"; then
7185   ac_cv_prog_NM=$NM
7186 elif test -n "$ac_cv_prog_NM"; then
7187   NM=$ac_cv_prog_NM
7188 fi
7189
7190 if test -n "$ac_cv_prog_NM"; then
7191   for ncn_progname in nm; do
7192     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7193 set dummy ${ncn_progname}; ac_word=$2
7194 echo "$as_me:$LINENO: checking for $ac_word" >&5
7195 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7196 if test "${ac_cv_prog_NM+set}" = set; then
7197   echo $ECHO_N "(cached) $ECHO_C" >&6
7198 else
7199   if test -n "$NM"; then
7200   ac_cv_prog_NM="$NM" # Let the user override the test.
7201 else
7202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7203 for as_dir in $PATH
7204 do
7205   IFS=$as_save_IFS
7206   test -z "$as_dir" && as_dir=.
7207   for ac_exec_ext in '' $ac_executable_extensions; do
7208   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7209     ac_cv_prog_NM="${ncn_progname}"
7210     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7211     break 2
7212   fi
7213 done
7214 done
7215
7216 fi
7217 fi
7218 NM=$ac_cv_prog_NM
7219 if test -n "$NM"; then
7220   echo "$as_me:$LINENO: result: $NM" >&5
7221 echo "${ECHO_T}$NM" >&6
7222 else
7223   echo "$as_me:$LINENO: result: no" >&5
7224 echo "${ECHO_T}no" >&6
7225 fi
7226
7227   done
7228 fi
7229
7230 for ncn_progname in nm; do
7231   if test -n "$ncn_tool_prefix"; then
7232     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7233 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7234 echo "$as_me:$LINENO: checking for $ac_word" >&5
7235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7236 if test "${ac_cv_prog_NM+set}" = set; then
7237   echo $ECHO_N "(cached) $ECHO_C" >&6
7238 else
7239   if test -n "$NM"; then
7240   ac_cv_prog_NM="$NM" # Let the user override the test.
7241 else
7242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7243 for as_dir in $PATH
7244 do
7245   IFS=$as_save_IFS
7246   test -z "$as_dir" && as_dir=.
7247   for ac_exec_ext in '' $ac_executable_extensions; do
7248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7249     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7251     break 2
7252   fi
7253 done
7254 done
7255
7256 fi
7257 fi
7258 NM=$ac_cv_prog_NM
7259 if test -n "$NM"; then
7260   echo "$as_me:$LINENO: result: $NM" >&5
7261 echo "${ECHO_T}$NM" >&6
7262 else
7263   echo "$as_me:$LINENO: result: no" >&5
7264 echo "${ECHO_T}no" >&6
7265 fi
7266
7267   fi
7268   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7269     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7270 set dummy ${ncn_progname}; ac_word=$2
7271 echo "$as_me:$LINENO: checking for $ac_word" >&5
7272 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7273 if test "${ac_cv_prog_NM+set}" = set; then
7274   echo $ECHO_N "(cached) $ECHO_C" >&6
7275 else
7276   if test -n "$NM"; then
7277   ac_cv_prog_NM="$NM" # Let the user override the test.
7278 else
7279 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7280 for as_dir in $PATH
7281 do
7282   IFS=$as_save_IFS
7283   test -z "$as_dir" && as_dir=.
7284   for ac_exec_ext in '' $ac_executable_extensions; do
7285   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7286     ac_cv_prog_NM="${ncn_progname}"
7287     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7288     break 2
7289   fi
7290 done
7291 done
7292
7293 fi
7294 fi
7295 NM=$ac_cv_prog_NM
7296 if test -n "$NM"; then
7297   echo "$as_me:$LINENO: result: $NM" >&5
7298 echo "${ECHO_T}$NM" >&6
7299 else
7300   echo "$as_me:$LINENO: result: no" >&5
7301 echo "${ECHO_T}no" >&6
7302 fi
7303
7304   fi
7305   test -n "$ac_cv_prog_NM" && break
7306 done
7307
7308 if test -z "$ac_cv_prog_NM" ; then
7309   set dummy nm
7310   if test $build = $host ; then
7311     NM="$2"
7312   else
7313     NM="${ncn_tool_prefix}$2"
7314   fi
7315 fi
7316
7317
7318
7319 if test -n "$RANLIB"; then
7320   ac_cv_prog_RANLIB=$RANLIB
7321 elif test -n "$ac_cv_prog_RANLIB"; then
7322   RANLIB=$ac_cv_prog_RANLIB
7323 fi
7324
7325 if test -n "$ac_cv_prog_RANLIB"; then
7326   for ncn_progname in ranlib; do
7327     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7328 set dummy ${ncn_progname}; ac_word=$2
7329 echo "$as_me:$LINENO: checking for $ac_word" >&5
7330 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7331 if test "${ac_cv_prog_RANLIB+set}" = set; then
7332   echo $ECHO_N "(cached) $ECHO_C" >&6
7333 else
7334   if test -n "$RANLIB"; then
7335   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7336 else
7337 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7338 for as_dir in $PATH
7339 do
7340   IFS=$as_save_IFS
7341   test -z "$as_dir" && as_dir=.
7342   for ac_exec_ext in '' $ac_executable_extensions; do
7343   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7344     ac_cv_prog_RANLIB="${ncn_progname}"
7345     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7346     break 2
7347   fi
7348 done
7349 done
7350
7351 fi
7352 fi
7353 RANLIB=$ac_cv_prog_RANLIB
7354 if test -n "$RANLIB"; then
7355   echo "$as_me:$LINENO: result: $RANLIB" >&5
7356 echo "${ECHO_T}$RANLIB" >&6
7357 else
7358   echo "$as_me:$LINENO: result: no" >&5
7359 echo "${ECHO_T}no" >&6
7360 fi
7361
7362   done
7363 fi
7364
7365 for ncn_progname in ranlib; do
7366   if test -n "$ncn_tool_prefix"; then
7367     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7368 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7369 echo "$as_me:$LINENO: checking for $ac_word" >&5
7370 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7371 if test "${ac_cv_prog_RANLIB+set}" = set; then
7372   echo $ECHO_N "(cached) $ECHO_C" >&6
7373 else
7374   if test -n "$RANLIB"; then
7375   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7376 else
7377 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7378 for as_dir in $PATH
7379 do
7380   IFS=$as_save_IFS
7381   test -z "$as_dir" && as_dir=.
7382   for ac_exec_ext in '' $ac_executable_extensions; do
7383   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7384     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7385     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7386     break 2
7387   fi
7388 done
7389 done
7390
7391 fi
7392 fi
7393 RANLIB=$ac_cv_prog_RANLIB
7394 if test -n "$RANLIB"; then
7395   echo "$as_me:$LINENO: result: $RANLIB" >&5
7396 echo "${ECHO_T}$RANLIB" >&6
7397 else
7398   echo "$as_me:$LINENO: result: no" >&5
7399 echo "${ECHO_T}no" >&6
7400 fi
7401
7402   fi
7403   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7404     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7405 set dummy ${ncn_progname}; ac_word=$2
7406 echo "$as_me:$LINENO: checking for $ac_word" >&5
7407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7408 if test "${ac_cv_prog_RANLIB+set}" = set; then
7409   echo $ECHO_N "(cached) $ECHO_C" >&6
7410 else
7411   if test -n "$RANLIB"; then
7412   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7413 else
7414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7415 for as_dir in $PATH
7416 do
7417   IFS=$as_save_IFS
7418   test -z "$as_dir" && as_dir=.
7419   for ac_exec_ext in '' $ac_executable_extensions; do
7420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7421     ac_cv_prog_RANLIB="${ncn_progname}"
7422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7423     break 2
7424   fi
7425 done
7426 done
7427
7428 fi
7429 fi
7430 RANLIB=$ac_cv_prog_RANLIB
7431 if test -n "$RANLIB"; then
7432   echo "$as_me:$LINENO: result: $RANLIB" >&5
7433 echo "${ECHO_T}$RANLIB" >&6
7434 else
7435   echo "$as_me:$LINENO: result: no" >&5
7436 echo "${ECHO_T}no" >&6
7437 fi
7438
7439   fi
7440   test -n "$ac_cv_prog_RANLIB" && break
7441 done
7442
7443 if test -z "$ac_cv_prog_RANLIB" ; then
7444   RANLIB=":"
7445 fi
7446
7447
7448
7449 if test -n "$STRIP"; then
7450   ac_cv_prog_STRIP=$STRIP
7451 elif test -n "$ac_cv_prog_STRIP"; then
7452   STRIP=$ac_cv_prog_STRIP
7453 fi
7454
7455 if test -n "$ac_cv_prog_STRIP"; then
7456   for ncn_progname in strip; do
7457     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7458 set dummy ${ncn_progname}; ac_word=$2
7459 echo "$as_me:$LINENO: checking for $ac_word" >&5
7460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7461 if test "${ac_cv_prog_STRIP+set}" = set; then
7462   echo $ECHO_N "(cached) $ECHO_C" >&6
7463 else
7464   if test -n "$STRIP"; then
7465   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7466 else
7467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7468 for as_dir in $PATH
7469 do
7470   IFS=$as_save_IFS
7471   test -z "$as_dir" && as_dir=.
7472   for ac_exec_ext in '' $ac_executable_extensions; do
7473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7474     ac_cv_prog_STRIP="${ncn_progname}"
7475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7476     break 2
7477   fi
7478 done
7479 done
7480
7481 fi
7482 fi
7483 STRIP=$ac_cv_prog_STRIP
7484 if test -n "$STRIP"; then
7485   echo "$as_me:$LINENO: result: $STRIP" >&5
7486 echo "${ECHO_T}$STRIP" >&6
7487 else
7488   echo "$as_me:$LINENO: result: no" >&5
7489 echo "${ECHO_T}no" >&6
7490 fi
7491
7492   done
7493 fi
7494
7495 for ncn_progname in strip; do
7496   if test -n "$ncn_tool_prefix"; then
7497     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7498 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7499 echo "$as_me:$LINENO: checking for $ac_word" >&5
7500 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7501 if test "${ac_cv_prog_STRIP+set}" = set; then
7502   echo $ECHO_N "(cached) $ECHO_C" >&6
7503 else
7504   if test -n "$STRIP"; then
7505   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7506 else
7507 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7508 for as_dir in $PATH
7509 do
7510   IFS=$as_save_IFS
7511   test -z "$as_dir" && as_dir=.
7512   for ac_exec_ext in '' $ac_executable_extensions; do
7513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7514     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7516     break 2
7517   fi
7518 done
7519 done
7520
7521 fi
7522 fi
7523 STRIP=$ac_cv_prog_STRIP
7524 if test -n "$STRIP"; then
7525   echo "$as_me:$LINENO: result: $STRIP" >&5
7526 echo "${ECHO_T}$STRIP" >&6
7527 else
7528   echo "$as_me:$LINENO: result: no" >&5
7529 echo "${ECHO_T}no" >&6
7530 fi
7531
7532   fi
7533   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7534     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7535 set dummy ${ncn_progname}; ac_word=$2
7536 echo "$as_me:$LINENO: checking for $ac_word" >&5
7537 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7538 if test "${ac_cv_prog_STRIP+set}" = set; then
7539   echo $ECHO_N "(cached) $ECHO_C" >&6
7540 else
7541   if test -n "$STRIP"; then
7542   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7543 else
7544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7545 for as_dir in $PATH
7546 do
7547   IFS=$as_save_IFS
7548   test -z "$as_dir" && as_dir=.
7549   for ac_exec_ext in '' $ac_executable_extensions; do
7550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7551     ac_cv_prog_STRIP="${ncn_progname}"
7552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7553     break 2
7554   fi
7555 done
7556 done
7557
7558 fi
7559 fi
7560 STRIP=$ac_cv_prog_STRIP
7561 if test -n "$STRIP"; then
7562   echo "$as_me:$LINENO: result: $STRIP" >&5
7563 echo "${ECHO_T}$STRIP" >&6
7564 else
7565   echo "$as_me:$LINENO: result: no" >&5
7566 echo "${ECHO_T}no" >&6
7567 fi
7568
7569   fi
7570   test -n "$ac_cv_prog_STRIP" && break
7571 done
7572
7573 if test -z "$ac_cv_prog_STRIP" ; then
7574   STRIP=":"
7575 fi
7576
7577
7578
7579 if test -n "$WINDRES"; then
7580   ac_cv_prog_WINDRES=$WINDRES
7581 elif test -n "$ac_cv_prog_WINDRES"; then
7582   WINDRES=$ac_cv_prog_WINDRES
7583 fi
7584
7585 if test -n "$ac_cv_prog_WINDRES"; then
7586   for ncn_progname in windres; do
7587     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7588 set dummy ${ncn_progname}; ac_word=$2
7589 echo "$as_me:$LINENO: checking for $ac_word" >&5
7590 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7591 if test "${ac_cv_prog_WINDRES+set}" = set; then
7592   echo $ECHO_N "(cached) $ECHO_C" >&6
7593 else
7594   if test -n "$WINDRES"; then
7595   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7596 else
7597 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7598 for as_dir in $PATH
7599 do
7600   IFS=$as_save_IFS
7601   test -z "$as_dir" && as_dir=.
7602   for ac_exec_ext in '' $ac_executable_extensions; do
7603   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7604     ac_cv_prog_WINDRES="${ncn_progname}"
7605     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7606     break 2
7607   fi
7608 done
7609 done
7610
7611 fi
7612 fi
7613 WINDRES=$ac_cv_prog_WINDRES
7614 if test -n "$WINDRES"; then
7615   echo "$as_me:$LINENO: result: $WINDRES" >&5
7616 echo "${ECHO_T}$WINDRES" >&6
7617 else
7618   echo "$as_me:$LINENO: result: no" >&5
7619 echo "${ECHO_T}no" >&6
7620 fi
7621
7622   done
7623 fi
7624
7625 for ncn_progname in windres; do
7626   if test -n "$ncn_tool_prefix"; then
7627     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7628 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7629 echo "$as_me:$LINENO: checking for $ac_word" >&5
7630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7631 if test "${ac_cv_prog_WINDRES+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test -n "$WINDRES"; then
7635   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7636 else
7637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7638 for as_dir in $PATH
7639 do
7640   IFS=$as_save_IFS
7641   test -z "$as_dir" && as_dir=.
7642   for ac_exec_ext in '' $ac_executable_extensions; do
7643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7644     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7646     break 2
7647   fi
7648 done
7649 done
7650
7651 fi
7652 fi
7653 WINDRES=$ac_cv_prog_WINDRES
7654 if test -n "$WINDRES"; then
7655   echo "$as_me:$LINENO: result: $WINDRES" >&5
7656 echo "${ECHO_T}$WINDRES" >&6
7657 else
7658   echo "$as_me:$LINENO: result: no" >&5
7659 echo "${ECHO_T}no" >&6
7660 fi
7661
7662   fi
7663   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7664     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7665 set dummy ${ncn_progname}; ac_word=$2
7666 echo "$as_me:$LINENO: checking for $ac_word" >&5
7667 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7668 if test "${ac_cv_prog_WINDRES+set}" = set; then
7669   echo $ECHO_N "(cached) $ECHO_C" >&6
7670 else
7671   if test -n "$WINDRES"; then
7672   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7673 else
7674 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7675 for as_dir in $PATH
7676 do
7677   IFS=$as_save_IFS
7678   test -z "$as_dir" && as_dir=.
7679   for ac_exec_ext in '' $ac_executable_extensions; do
7680   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7681     ac_cv_prog_WINDRES="${ncn_progname}"
7682     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7683     break 2
7684   fi
7685 done
7686 done
7687
7688 fi
7689 fi
7690 WINDRES=$ac_cv_prog_WINDRES
7691 if test -n "$WINDRES"; then
7692   echo "$as_me:$LINENO: result: $WINDRES" >&5
7693 echo "${ECHO_T}$WINDRES" >&6
7694 else
7695   echo "$as_me:$LINENO: result: no" >&5
7696 echo "${ECHO_T}no" >&6
7697 fi
7698
7699   fi
7700   test -n "$ac_cv_prog_WINDRES" && break
7701 done
7702
7703 if test -z "$ac_cv_prog_WINDRES" ; then
7704   set dummy windres
7705   if test $build = $host ; then
7706     WINDRES="$2"
7707   else
7708     WINDRES="${ncn_tool_prefix}$2"
7709   fi
7710 fi
7711
7712
7713
7714 if test -n "$WINDMC"; then
7715   ac_cv_prog_WINDMC=$WINDMC
7716 elif test -n "$ac_cv_prog_WINDMC"; then
7717   WINDMC=$ac_cv_prog_WINDMC
7718 fi
7719
7720 if test -n "$ac_cv_prog_WINDMC"; then
7721   for ncn_progname in windmc; do
7722     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7723 set dummy ${ncn_progname}; ac_word=$2
7724 echo "$as_me:$LINENO: checking for $ac_word" >&5
7725 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7726 if test "${ac_cv_prog_WINDMC+set}" = set; then
7727   echo $ECHO_N "(cached) $ECHO_C" >&6
7728 else
7729   if test -n "$WINDMC"; then
7730   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7731 else
7732 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7733 for as_dir in $PATH
7734 do
7735   IFS=$as_save_IFS
7736   test -z "$as_dir" && as_dir=.
7737   for ac_exec_ext in '' $ac_executable_extensions; do
7738   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7739     ac_cv_prog_WINDMC="${ncn_progname}"
7740     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7741     break 2
7742   fi
7743 done
7744 done
7745
7746 fi
7747 fi
7748 WINDMC=$ac_cv_prog_WINDMC
7749 if test -n "$WINDMC"; then
7750   echo "$as_me:$LINENO: result: $WINDMC" >&5
7751 echo "${ECHO_T}$WINDMC" >&6
7752 else
7753   echo "$as_me:$LINENO: result: no" >&5
7754 echo "${ECHO_T}no" >&6
7755 fi
7756
7757   done
7758 fi
7759
7760 for ncn_progname in windmc; do
7761   if test -n "$ncn_tool_prefix"; then
7762     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7763 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7764 echo "$as_me:$LINENO: checking for $ac_word" >&5
7765 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7766 if test "${ac_cv_prog_WINDMC+set}" = set; then
7767   echo $ECHO_N "(cached) $ECHO_C" >&6
7768 else
7769   if test -n "$WINDMC"; then
7770   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7771 else
7772 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7773 for as_dir in $PATH
7774 do
7775   IFS=$as_save_IFS
7776   test -z "$as_dir" && as_dir=.
7777   for ac_exec_ext in '' $ac_executable_extensions; do
7778   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7779     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7780     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7781     break 2
7782   fi
7783 done
7784 done
7785
7786 fi
7787 fi
7788 WINDMC=$ac_cv_prog_WINDMC
7789 if test -n "$WINDMC"; then
7790   echo "$as_me:$LINENO: result: $WINDMC" >&5
7791 echo "${ECHO_T}$WINDMC" >&6
7792 else
7793   echo "$as_me:$LINENO: result: no" >&5
7794 echo "${ECHO_T}no" >&6
7795 fi
7796
7797   fi
7798   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7799     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7800 set dummy ${ncn_progname}; ac_word=$2
7801 echo "$as_me:$LINENO: checking for $ac_word" >&5
7802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7803 if test "${ac_cv_prog_WINDMC+set}" = set; then
7804   echo $ECHO_N "(cached) $ECHO_C" >&6
7805 else
7806   if test -n "$WINDMC"; then
7807   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7808 else
7809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7810 for as_dir in $PATH
7811 do
7812   IFS=$as_save_IFS
7813   test -z "$as_dir" && as_dir=.
7814   for ac_exec_ext in '' $ac_executable_extensions; do
7815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7816     ac_cv_prog_WINDMC="${ncn_progname}"
7817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7818     break 2
7819   fi
7820 done
7821 done
7822
7823 fi
7824 fi
7825 WINDMC=$ac_cv_prog_WINDMC
7826 if test -n "$WINDMC"; then
7827   echo "$as_me:$LINENO: result: $WINDMC" >&5
7828 echo "${ECHO_T}$WINDMC" >&6
7829 else
7830   echo "$as_me:$LINENO: result: no" >&5
7831 echo "${ECHO_T}no" >&6
7832 fi
7833
7834   fi
7835   test -n "$ac_cv_prog_WINDMC" && break
7836 done
7837
7838 if test -z "$ac_cv_prog_WINDMC" ; then
7839   set dummy windmc
7840   if test $build = $host ; then
7841     WINDMC="$2"
7842   else
7843     WINDMC="${ncn_tool_prefix}$2"
7844   fi
7845 fi
7846
7847
7848
7849 if test -n "$OBJCOPY"; then
7850   ac_cv_prog_OBJCOPY=$OBJCOPY
7851 elif test -n "$ac_cv_prog_OBJCOPY"; then
7852   OBJCOPY=$ac_cv_prog_OBJCOPY
7853 fi
7854
7855 if test -n "$ac_cv_prog_OBJCOPY"; then
7856   for ncn_progname in objcopy; do
7857     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7858 set dummy ${ncn_progname}; ac_word=$2
7859 echo "$as_me:$LINENO: checking for $ac_word" >&5
7860 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7861 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7862   echo $ECHO_N "(cached) $ECHO_C" >&6
7863 else
7864   if test -n "$OBJCOPY"; then
7865   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7866 else
7867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7868 for as_dir in $PATH
7869 do
7870   IFS=$as_save_IFS
7871   test -z "$as_dir" && as_dir=.
7872   for ac_exec_ext in '' $ac_executable_extensions; do
7873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7874     ac_cv_prog_OBJCOPY="${ncn_progname}"
7875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7876     break 2
7877   fi
7878 done
7879 done
7880
7881 fi
7882 fi
7883 OBJCOPY=$ac_cv_prog_OBJCOPY
7884 if test -n "$OBJCOPY"; then
7885   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7886 echo "${ECHO_T}$OBJCOPY" >&6
7887 else
7888   echo "$as_me:$LINENO: result: no" >&5
7889 echo "${ECHO_T}no" >&6
7890 fi
7891
7892   done
7893 fi
7894
7895 for ncn_progname in objcopy; do
7896   if test -n "$ncn_tool_prefix"; then
7897     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7898 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7899 echo "$as_me:$LINENO: checking for $ac_word" >&5
7900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7901 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7902   echo $ECHO_N "(cached) $ECHO_C" >&6
7903 else
7904   if test -n "$OBJCOPY"; then
7905   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7906 else
7907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7908 for as_dir in $PATH
7909 do
7910   IFS=$as_save_IFS
7911   test -z "$as_dir" && as_dir=.
7912   for ac_exec_ext in '' $ac_executable_extensions; do
7913   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7914     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7915     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7916     break 2
7917   fi
7918 done
7919 done
7920
7921 fi
7922 fi
7923 OBJCOPY=$ac_cv_prog_OBJCOPY
7924 if test -n "$OBJCOPY"; then
7925   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7926 echo "${ECHO_T}$OBJCOPY" >&6
7927 else
7928   echo "$as_me:$LINENO: result: no" >&5
7929 echo "${ECHO_T}no" >&6
7930 fi
7931
7932   fi
7933   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7934     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7935 set dummy ${ncn_progname}; ac_word=$2
7936 echo "$as_me:$LINENO: checking for $ac_word" >&5
7937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7938 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7939   echo $ECHO_N "(cached) $ECHO_C" >&6
7940 else
7941   if test -n "$OBJCOPY"; then
7942   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7943 else
7944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7945 for as_dir in $PATH
7946 do
7947   IFS=$as_save_IFS
7948   test -z "$as_dir" && as_dir=.
7949   for ac_exec_ext in '' $ac_executable_extensions; do
7950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7951     ac_cv_prog_OBJCOPY="${ncn_progname}"
7952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7953     break 2
7954   fi
7955 done
7956 done
7957
7958 fi
7959 fi
7960 OBJCOPY=$ac_cv_prog_OBJCOPY
7961 if test -n "$OBJCOPY"; then
7962   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7963 echo "${ECHO_T}$OBJCOPY" >&6
7964 else
7965   echo "$as_me:$LINENO: result: no" >&5
7966 echo "${ECHO_T}no" >&6
7967 fi
7968
7969   fi
7970   test -n "$ac_cv_prog_OBJCOPY" && break
7971 done
7972
7973 if test -z "$ac_cv_prog_OBJCOPY" ; then
7974   set dummy objcopy
7975   if test $build = $host ; then
7976     OBJCOPY="$2"
7977   else
7978     OBJCOPY="${ncn_tool_prefix}$2"
7979   fi
7980 fi
7981
7982
7983
7984 if test -n "$OBJDUMP"; then
7985   ac_cv_prog_OBJDUMP=$OBJDUMP
7986 elif test -n "$ac_cv_prog_OBJDUMP"; then
7987   OBJDUMP=$ac_cv_prog_OBJDUMP
7988 fi
7989
7990 if test -n "$ac_cv_prog_OBJDUMP"; then
7991   for ncn_progname in objdump; do
7992     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7993 set dummy ${ncn_progname}; ac_word=$2
7994 echo "$as_me:$LINENO: checking for $ac_word" >&5
7995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7996 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7997   echo $ECHO_N "(cached) $ECHO_C" >&6
7998 else
7999   if test -n "$OBJDUMP"; then
8000   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8001 else
8002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8003 for as_dir in $PATH
8004 do
8005   IFS=$as_save_IFS
8006   test -z "$as_dir" && as_dir=.
8007   for ac_exec_ext in '' $ac_executable_extensions; do
8008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8009     ac_cv_prog_OBJDUMP="${ncn_progname}"
8010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8011     break 2
8012   fi
8013 done
8014 done
8015
8016 fi
8017 fi
8018 OBJDUMP=$ac_cv_prog_OBJDUMP
8019 if test -n "$OBJDUMP"; then
8020   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8021 echo "${ECHO_T}$OBJDUMP" >&6
8022 else
8023   echo "$as_me:$LINENO: result: no" >&5
8024 echo "${ECHO_T}no" >&6
8025 fi
8026
8027   done
8028 fi
8029
8030 for ncn_progname in objdump; do
8031   if test -n "$ncn_tool_prefix"; then
8032     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8033 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8034 echo "$as_me:$LINENO: checking for $ac_word" >&5
8035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8036 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8037   echo $ECHO_N "(cached) $ECHO_C" >&6
8038 else
8039   if test -n "$OBJDUMP"; then
8040   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8041 else
8042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8043 for as_dir in $PATH
8044 do
8045   IFS=$as_save_IFS
8046   test -z "$as_dir" && as_dir=.
8047   for ac_exec_ext in '' $ac_executable_extensions; do
8048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8049     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8051     break 2
8052   fi
8053 done
8054 done
8055
8056 fi
8057 fi
8058 OBJDUMP=$ac_cv_prog_OBJDUMP
8059 if test -n "$OBJDUMP"; then
8060   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8061 echo "${ECHO_T}$OBJDUMP" >&6
8062 else
8063   echo "$as_me:$LINENO: result: no" >&5
8064 echo "${ECHO_T}no" >&6
8065 fi
8066
8067   fi
8068   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8070 set dummy ${ncn_progname}; ac_word=$2
8071 echo "$as_me:$LINENO: checking for $ac_word" >&5
8072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8073 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8074   echo $ECHO_N "(cached) $ECHO_C" >&6
8075 else
8076   if test -n "$OBJDUMP"; then
8077   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8078 else
8079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8080 for as_dir in $PATH
8081 do
8082   IFS=$as_save_IFS
8083   test -z "$as_dir" && as_dir=.
8084   for ac_exec_ext in '' $ac_executable_extensions; do
8085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8086     ac_cv_prog_OBJDUMP="${ncn_progname}"
8087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8088     break 2
8089   fi
8090 done
8091 done
8092
8093 fi
8094 fi
8095 OBJDUMP=$ac_cv_prog_OBJDUMP
8096 if test -n "$OBJDUMP"; then
8097   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8098 echo "${ECHO_T}$OBJDUMP" >&6
8099 else
8100   echo "$as_me:$LINENO: result: no" >&5
8101 echo "${ECHO_T}no" >&6
8102 fi
8103
8104   fi
8105   test -n "$ac_cv_prog_OBJDUMP" && break
8106 done
8107
8108 if test -z "$ac_cv_prog_OBJDUMP" ; then
8109   set dummy objdump
8110   if test $build = $host ; then
8111     OBJDUMP="$2"
8112   else
8113     OBJDUMP="${ncn_tool_prefix}$2"
8114   fi
8115 fi
8116
8117
8118
8119
8120
8121
8122 # Target tools.
8123
8124 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8125 if test "${with_build_time_tools+set}" = set; then
8126   withval="$with_build_time_tools"
8127   case x"$withval" in
8128      x/*) ;;
8129      *)
8130        with_build_time_tools=
8131        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8132 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8133        ;;
8134    esac
8135 else
8136   with_build_time_tools=
8137 fi;
8138
8139
8140
8141 if test -n "$CC_FOR_TARGET"; then
8142   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8143 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8144   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8145 fi
8146
8147 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8148   for ncn_progname in cc gcc; do
8149     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8150 set dummy ${ncn_progname}; ac_word=$2
8151 echo "$as_me:$LINENO: checking for $ac_word" >&5
8152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8153 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8154   echo $ECHO_N "(cached) $ECHO_C" >&6
8155 else
8156   if test -n "$CC_FOR_TARGET"; then
8157   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8158 else
8159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8160 for as_dir in $PATH
8161 do
8162   IFS=$as_save_IFS
8163   test -z "$as_dir" && as_dir=.
8164   for ac_exec_ext in '' $ac_executable_extensions; do
8165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8166     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8168     break 2
8169   fi
8170 done
8171 done
8172
8173 fi
8174 fi
8175 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8176 if test -n "$CC_FOR_TARGET"; then
8177   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8178 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8179 else
8180   echo "$as_me:$LINENO: result: no" >&5
8181 echo "${ECHO_T}no" >&6
8182 fi
8183
8184   done
8185 fi
8186
8187 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8188   for ncn_progname in cc gcc; do
8189     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8190 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8191     if test -x $with_build_time_tools/${ncn_progname}; then
8192       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8193       echo "$as_me:$LINENO: result: yes" >&5
8194 echo "${ECHO_T}yes" >&6
8195       break
8196     else
8197       echo "$as_me:$LINENO: result: no" >&5
8198 echo "${ECHO_T}no" >&6
8199     fi
8200   done
8201 fi
8202
8203 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8204   for ncn_progname in cc gcc; do
8205     if test -n "$ncn_target_tool_prefix"; then
8206       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8207 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8208 echo "$as_me:$LINENO: checking for $ac_word" >&5
8209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8210 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8211   echo $ECHO_N "(cached) $ECHO_C" >&6
8212 else
8213   if test -n "$CC_FOR_TARGET"; then
8214   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8215 else
8216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8217 for as_dir in $PATH
8218 do
8219   IFS=$as_save_IFS
8220   test -z "$as_dir" && as_dir=.
8221   for ac_exec_ext in '' $ac_executable_extensions; do
8222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8223     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8225     break 2
8226   fi
8227 done
8228 done
8229
8230 fi
8231 fi
8232 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8233 if test -n "$CC_FOR_TARGET"; then
8234   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8235 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8236 else
8237   echo "$as_me:$LINENO: result: no" >&5
8238 echo "${ECHO_T}no" >&6
8239 fi
8240
8241     fi
8242     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8243       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8244 set dummy ${ncn_progname}; ac_word=$2
8245 echo "$as_me:$LINENO: checking for $ac_word" >&5
8246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8247 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8248   echo $ECHO_N "(cached) $ECHO_C" >&6
8249 else
8250   if test -n "$CC_FOR_TARGET"; then
8251   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8252 else
8253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8254 for as_dir in $PATH
8255 do
8256   IFS=$as_save_IFS
8257   test -z "$as_dir" && as_dir=.
8258   for ac_exec_ext in '' $ac_executable_extensions; do
8259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8260     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8262     break 2
8263   fi
8264 done
8265 done
8266
8267 fi
8268 fi
8269 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8270 if test -n "$CC_FOR_TARGET"; then
8271   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8272 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8273 else
8274   echo "$as_me:$LINENO: result: no" >&5
8275 echo "${ECHO_T}no" >&6
8276 fi
8277
8278     fi
8279     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8280   done
8281 fi
8282
8283 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8284   set dummy cc gcc
8285   if test $build = $target ; then
8286     CC_FOR_TARGET="$2"
8287   else
8288     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8289   fi
8290 else
8291   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8292 fi
8293
8294
8295
8296 if test -n "$CXX_FOR_TARGET"; then
8297   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8298 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8299   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8300 fi
8301
8302 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8303   for ncn_progname in c++ g++ cxx gxx; do
8304     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8305 set dummy ${ncn_progname}; ac_word=$2
8306 echo "$as_me:$LINENO: checking for $ac_word" >&5
8307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8308 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8309   echo $ECHO_N "(cached) $ECHO_C" >&6
8310 else
8311   if test -n "$CXX_FOR_TARGET"; then
8312   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8313 else
8314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8315 for as_dir in $PATH
8316 do
8317   IFS=$as_save_IFS
8318   test -z "$as_dir" && as_dir=.
8319   for ac_exec_ext in '' $ac_executable_extensions; do
8320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8321     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8323     break 2
8324   fi
8325 done
8326 done
8327
8328 fi
8329 fi
8330 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8331 if test -n "$CXX_FOR_TARGET"; then
8332   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8333 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8334 else
8335   echo "$as_me:$LINENO: result: no" >&5
8336 echo "${ECHO_T}no" >&6
8337 fi
8338
8339   done
8340 fi
8341
8342 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8343   for ncn_progname in c++ g++ cxx gxx; do
8344     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8345 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8346     if test -x $with_build_time_tools/${ncn_progname}; then
8347       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8348       echo "$as_me:$LINENO: result: yes" >&5
8349 echo "${ECHO_T}yes" >&6
8350       break
8351     else
8352       echo "$as_me:$LINENO: result: no" >&5
8353 echo "${ECHO_T}no" >&6
8354     fi
8355   done
8356 fi
8357
8358 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8359   for ncn_progname in c++ g++ cxx gxx; do
8360     if test -n "$ncn_target_tool_prefix"; then
8361       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8362 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8363 echo "$as_me:$LINENO: checking for $ac_word" >&5
8364 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8365 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8366   echo $ECHO_N "(cached) $ECHO_C" >&6
8367 else
8368   if test -n "$CXX_FOR_TARGET"; then
8369   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8370 else
8371 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8372 for as_dir in $PATH
8373 do
8374   IFS=$as_save_IFS
8375   test -z "$as_dir" && as_dir=.
8376   for ac_exec_ext in '' $ac_executable_extensions; do
8377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8378     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8380     break 2
8381   fi
8382 done
8383 done
8384
8385 fi
8386 fi
8387 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8388 if test -n "$CXX_FOR_TARGET"; then
8389   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8390 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8391 else
8392   echo "$as_me:$LINENO: result: no" >&5
8393 echo "${ECHO_T}no" >&6
8394 fi
8395
8396     fi
8397     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8398       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8399 set dummy ${ncn_progname}; ac_word=$2
8400 echo "$as_me:$LINENO: checking for $ac_word" >&5
8401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8402 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8403   echo $ECHO_N "(cached) $ECHO_C" >&6
8404 else
8405   if test -n "$CXX_FOR_TARGET"; then
8406   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8407 else
8408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8409 for as_dir in $PATH
8410 do
8411   IFS=$as_save_IFS
8412   test -z "$as_dir" && as_dir=.
8413   for ac_exec_ext in '' $ac_executable_extensions; do
8414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8415     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8417     break 2
8418   fi
8419 done
8420 done
8421
8422 fi
8423 fi
8424 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8425 if test -n "$CXX_FOR_TARGET"; then
8426   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8427 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8428 else
8429   echo "$as_me:$LINENO: result: no" >&5
8430 echo "${ECHO_T}no" >&6
8431 fi
8432
8433     fi
8434     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8435   done
8436 fi
8437
8438 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8439   set dummy c++ g++ cxx gxx
8440   if test $build = $target ; then
8441     CXX_FOR_TARGET="$2"
8442   else
8443     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8444   fi
8445 else
8446   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8447 fi
8448
8449
8450
8451 if test -n "$GCC_FOR_TARGET"; then
8452   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8453 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8454   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8455 fi
8456
8457 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8458   for ncn_progname in gcc; do
8459     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8460 set dummy ${ncn_progname}; ac_word=$2
8461 echo "$as_me:$LINENO: checking for $ac_word" >&5
8462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8463 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8464   echo $ECHO_N "(cached) $ECHO_C" >&6
8465 else
8466   if test -n "$GCC_FOR_TARGET"; then
8467   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8468 else
8469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8470 for as_dir in $PATH
8471 do
8472   IFS=$as_save_IFS
8473   test -z "$as_dir" && as_dir=.
8474   for ac_exec_ext in '' $ac_executable_extensions; do
8475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8476     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8478     break 2
8479   fi
8480 done
8481 done
8482
8483 fi
8484 fi
8485 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8486 if test -n "$GCC_FOR_TARGET"; then
8487   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8488 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8489 else
8490   echo "$as_me:$LINENO: result: no" >&5
8491 echo "${ECHO_T}no" >&6
8492 fi
8493
8494   done
8495 fi
8496
8497 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8498   for ncn_progname in gcc; do
8499     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8500 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8501     if test -x $with_build_time_tools/${ncn_progname}; then
8502       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8503       echo "$as_me:$LINENO: result: yes" >&5
8504 echo "${ECHO_T}yes" >&6
8505       break
8506     else
8507       echo "$as_me:$LINENO: result: no" >&5
8508 echo "${ECHO_T}no" >&6
8509     fi
8510   done
8511 fi
8512
8513 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8514   for ncn_progname in gcc; do
8515     if test -n "$ncn_target_tool_prefix"; then
8516       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8517 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8518 echo "$as_me:$LINENO: checking for $ac_word" >&5
8519 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8520 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8521   echo $ECHO_N "(cached) $ECHO_C" >&6
8522 else
8523   if test -n "$GCC_FOR_TARGET"; then
8524   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8525 else
8526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8527 for as_dir in $PATH
8528 do
8529   IFS=$as_save_IFS
8530   test -z "$as_dir" && as_dir=.
8531   for ac_exec_ext in '' $ac_executable_extensions; do
8532   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8533     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8534     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8535     break 2
8536   fi
8537 done
8538 done
8539
8540 fi
8541 fi
8542 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8543 if test -n "$GCC_FOR_TARGET"; then
8544   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8545 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8546 else
8547   echo "$as_me:$LINENO: result: no" >&5
8548 echo "${ECHO_T}no" >&6
8549 fi
8550
8551     fi
8552     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8553       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8554 set dummy ${ncn_progname}; ac_word=$2
8555 echo "$as_me:$LINENO: checking for $ac_word" >&5
8556 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8557 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8558   echo $ECHO_N "(cached) $ECHO_C" >&6
8559 else
8560   if test -n "$GCC_FOR_TARGET"; then
8561   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8562 else
8563 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8564 for as_dir in $PATH
8565 do
8566   IFS=$as_save_IFS
8567   test -z "$as_dir" && as_dir=.
8568   for ac_exec_ext in '' $ac_executable_extensions; do
8569   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8570     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8571     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8572     break 2
8573   fi
8574 done
8575 done
8576
8577 fi
8578 fi
8579 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8580 if test -n "$GCC_FOR_TARGET"; then
8581   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8582 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8583 else
8584   echo "$as_me:$LINENO: result: no" >&5
8585 echo "${ECHO_T}no" >&6
8586 fi
8587
8588     fi
8589     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8590   done
8591 fi
8592
8593 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8594   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8595 else
8596   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8597 fi
8598
8599
8600
8601 if test -n "$GCJ_FOR_TARGET"; then
8602   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8603 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8604   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8605 fi
8606
8607 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8608   for ncn_progname in gcj; do
8609     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8610 set dummy ${ncn_progname}; ac_word=$2
8611 echo "$as_me:$LINENO: checking for $ac_word" >&5
8612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8613 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8614   echo $ECHO_N "(cached) $ECHO_C" >&6
8615 else
8616   if test -n "$GCJ_FOR_TARGET"; then
8617   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8618 else
8619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8620 for as_dir in $PATH
8621 do
8622   IFS=$as_save_IFS
8623   test -z "$as_dir" && as_dir=.
8624   for ac_exec_ext in '' $ac_executable_extensions; do
8625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8626     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8628     break 2
8629   fi
8630 done
8631 done
8632
8633 fi
8634 fi
8635 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8636 if test -n "$GCJ_FOR_TARGET"; then
8637   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8638 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8639 else
8640   echo "$as_me:$LINENO: result: no" >&5
8641 echo "${ECHO_T}no" >&6
8642 fi
8643
8644   done
8645 fi
8646
8647 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8648   for ncn_progname in gcj; do
8649     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8650 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8651     if test -x $with_build_time_tools/${ncn_progname}; then
8652       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8653       echo "$as_me:$LINENO: result: yes" >&5
8654 echo "${ECHO_T}yes" >&6
8655       break
8656     else
8657       echo "$as_me:$LINENO: result: no" >&5
8658 echo "${ECHO_T}no" >&6
8659     fi
8660   done
8661 fi
8662
8663 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8664   for ncn_progname in gcj; do
8665     if test -n "$ncn_target_tool_prefix"; then
8666       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8667 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8668 echo "$as_me:$LINENO: checking for $ac_word" >&5
8669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8670 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8671   echo $ECHO_N "(cached) $ECHO_C" >&6
8672 else
8673   if test -n "$GCJ_FOR_TARGET"; then
8674   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8675 else
8676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8677 for as_dir in $PATH
8678 do
8679   IFS=$as_save_IFS
8680   test -z "$as_dir" && as_dir=.
8681   for ac_exec_ext in '' $ac_executable_extensions; do
8682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8683     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8685     break 2
8686   fi
8687 done
8688 done
8689
8690 fi
8691 fi
8692 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8693 if test -n "$GCJ_FOR_TARGET"; then
8694   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8695 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8696 else
8697   echo "$as_me:$LINENO: result: no" >&5
8698 echo "${ECHO_T}no" >&6
8699 fi
8700
8701     fi
8702     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8703       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8704 set dummy ${ncn_progname}; ac_word=$2
8705 echo "$as_me:$LINENO: checking for $ac_word" >&5
8706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8707 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8708   echo $ECHO_N "(cached) $ECHO_C" >&6
8709 else
8710   if test -n "$GCJ_FOR_TARGET"; then
8711   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8712 else
8713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8714 for as_dir in $PATH
8715 do
8716   IFS=$as_save_IFS
8717   test -z "$as_dir" && as_dir=.
8718   for ac_exec_ext in '' $ac_executable_extensions; do
8719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8720     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8722     break 2
8723   fi
8724 done
8725 done
8726
8727 fi
8728 fi
8729 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8730 if test -n "$GCJ_FOR_TARGET"; then
8731   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8732 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8733 else
8734   echo "$as_me:$LINENO: result: no" >&5
8735 echo "${ECHO_T}no" >&6
8736 fi
8737
8738     fi
8739     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8740   done
8741 fi
8742
8743 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8744   set dummy gcj
8745   if test $build = $target ; then
8746     GCJ_FOR_TARGET="$2"
8747   else
8748     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8749   fi
8750 else
8751   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8752 fi
8753
8754
8755
8756 if test -n "$GFORTRAN_FOR_TARGET"; then
8757   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8758 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8759   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8760 fi
8761
8762 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8763   for ncn_progname in gfortran; do
8764     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8765 set dummy ${ncn_progname}; ac_word=$2
8766 echo "$as_me:$LINENO: checking for $ac_word" >&5
8767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8768 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8769   echo $ECHO_N "(cached) $ECHO_C" >&6
8770 else
8771   if test -n "$GFORTRAN_FOR_TARGET"; then
8772   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8773 else
8774 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8775 for as_dir in $PATH
8776 do
8777   IFS=$as_save_IFS
8778   test -z "$as_dir" && as_dir=.
8779   for ac_exec_ext in '' $ac_executable_extensions; do
8780   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8781     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8782     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8783     break 2
8784   fi
8785 done
8786 done
8787
8788 fi
8789 fi
8790 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8791 if test -n "$GFORTRAN_FOR_TARGET"; then
8792   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8793 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8794 else
8795   echo "$as_me:$LINENO: result: no" >&5
8796 echo "${ECHO_T}no" >&6
8797 fi
8798
8799   done
8800 fi
8801
8802 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8803   for ncn_progname in gfortran; do
8804     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8805 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8806     if test -x $with_build_time_tools/${ncn_progname}; then
8807       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8808       echo "$as_me:$LINENO: result: yes" >&5
8809 echo "${ECHO_T}yes" >&6
8810       break
8811     else
8812       echo "$as_me:$LINENO: result: no" >&5
8813 echo "${ECHO_T}no" >&6
8814     fi
8815   done
8816 fi
8817
8818 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8819   for ncn_progname in gfortran; do
8820     if test -n "$ncn_target_tool_prefix"; then
8821       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8822 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8823 echo "$as_me:$LINENO: checking for $ac_word" >&5
8824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8825 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8826   echo $ECHO_N "(cached) $ECHO_C" >&6
8827 else
8828   if test -n "$GFORTRAN_FOR_TARGET"; then
8829   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8830 else
8831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8832 for as_dir in $PATH
8833 do
8834   IFS=$as_save_IFS
8835   test -z "$as_dir" && as_dir=.
8836   for ac_exec_ext in '' $ac_executable_extensions; do
8837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8838     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8840     break 2
8841   fi
8842 done
8843 done
8844
8845 fi
8846 fi
8847 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8848 if test -n "$GFORTRAN_FOR_TARGET"; then
8849   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8850 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8851 else
8852   echo "$as_me:$LINENO: result: no" >&5
8853 echo "${ECHO_T}no" >&6
8854 fi
8855
8856     fi
8857     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8858       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8859 set dummy ${ncn_progname}; ac_word=$2
8860 echo "$as_me:$LINENO: checking for $ac_word" >&5
8861 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8862 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8863   echo $ECHO_N "(cached) $ECHO_C" >&6
8864 else
8865   if test -n "$GFORTRAN_FOR_TARGET"; then
8866   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8867 else
8868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8869 for as_dir in $PATH
8870 do
8871   IFS=$as_save_IFS
8872   test -z "$as_dir" && as_dir=.
8873   for ac_exec_ext in '' $ac_executable_extensions; do
8874   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8875     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8876     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8877     break 2
8878   fi
8879 done
8880 done
8881
8882 fi
8883 fi
8884 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8885 if test -n "$GFORTRAN_FOR_TARGET"; then
8886   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8887 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8888 else
8889   echo "$as_me:$LINENO: result: no" >&5
8890 echo "${ECHO_T}no" >&6
8891 fi
8892
8893     fi
8894     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8895   done
8896 fi
8897
8898 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8899   set dummy gfortran
8900   if test $build = $target ; then
8901     GFORTRAN_FOR_TARGET="$2"
8902   else
8903     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8904   fi
8905 else
8906   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8907 fi
8908
8909
8910
8911 cat > conftest.c << \EOF
8912 #ifdef __GNUC__
8913   gcc_yay;
8914 #endif
8915 EOF
8916 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8917   have_gcc_for_target=yes
8918 else
8919   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8920   have_gcc_for_target=no
8921 fi
8922 rm conftest.c
8923
8924
8925
8926
8927 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8928   if test -n "$with_build_time_tools"; then
8929     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8930 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8931     if test -x $with_build_time_tools/ar; then
8932       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8933       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8934       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8935 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8936     else
8937       echo "$as_me:$LINENO: result: no" >&5
8938 echo "${ECHO_T}no" >&6
8939     fi
8940   elif test $build != $host && test $have_gcc_for_target = yes; then
8941     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8942     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8943     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8944   fi
8945 fi
8946 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8947   # Extract the first word of "ar", so it can be a program name with args.
8948 set dummy ar; ac_word=$2
8949 echo "$as_me:$LINENO: checking for $ac_word" >&5
8950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8951 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8952   echo $ECHO_N "(cached) $ECHO_C" >&6
8953 else
8954   case $AR_FOR_TARGET in
8955   [\\/]* | ?:[\\/]*)
8956   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8957   ;;
8958   *)
8959   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8960 for as_dir in $gcc_cv_tool_dirs
8961 do
8962   IFS=$as_save_IFS
8963   test -z "$as_dir" && as_dir=.
8964   for ac_exec_ext in '' $ac_executable_extensions; do
8965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8966     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8968     break 2
8969   fi
8970 done
8971 done
8972
8973   ;;
8974 esac
8975 fi
8976 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8977
8978 if test -n "$AR_FOR_TARGET"; then
8979   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8980 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8981 else
8982   echo "$as_me:$LINENO: result: no" >&5
8983 echo "${ECHO_T}no" >&6
8984 fi
8985
8986 fi
8987 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8988
8989
8990 if test -n "$AR_FOR_TARGET"; then
8991   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8992 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8993   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8994 fi
8995
8996 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8997   for ncn_progname in ar; do
8998     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8999 set dummy ${ncn_progname}; ac_word=$2
9000 echo "$as_me:$LINENO: checking for $ac_word" >&5
9001 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9002 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9003   echo $ECHO_N "(cached) $ECHO_C" >&6
9004 else
9005   if test -n "$AR_FOR_TARGET"; then
9006   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9007 else
9008 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9009 for as_dir in $PATH
9010 do
9011   IFS=$as_save_IFS
9012   test -z "$as_dir" && as_dir=.
9013   for ac_exec_ext in '' $ac_executable_extensions; do
9014   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9015     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9016     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9017     break 2
9018   fi
9019 done
9020 done
9021
9022 fi
9023 fi
9024 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9025 if test -n "$AR_FOR_TARGET"; then
9026   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9027 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9028 else
9029   echo "$as_me:$LINENO: result: no" >&5
9030 echo "${ECHO_T}no" >&6
9031 fi
9032
9033   done
9034 fi
9035
9036 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9037   for ncn_progname in ar; do
9038     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9039 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9040     if test -x $with_build_time_tools/${ncn_progname}; then
9041       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9042       echo "$as_me:$LINENO: result: yes" >&5
9043 echo "${ECHO_T}yes" >&6
9044       break
9045     else
9046       echo "$as_me:$LINENO: result: no" >&5
9047 echo "${ECHO_T}no" >&6
9048     fi
9049   done
9050 fi
9051
9052 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9053   for ncn_progname in ar; do
9054     if test -n "$ncn_target_tool_prefix"; then
9055       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9056 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9057 echo "$as_me:$LINENO: checking for $ac_word" >&5
9058 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9059 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9060   echo $ECHO_N "(cached) $ECHO_C" >&6
9061 else
9062   if test -n "$AR_FOR_TARGET"; then
9063   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9064 else
9065 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9066 for as_dir in $PATH
9067 do
9068   IFS=$as_save_IFS
9069   test -z "$as_dir" && as_dir=.
9070   for ac_exec_ext in '' $ac_executable_extensions; do
9071   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9072     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9073     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9074     break 2
9075   fi
9076 done
9077 done
9078
9079 fi
9080 fi
9081 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9082 if test -n "$AR_FOR_TARGET"; then
9083   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9084 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9085 else
9086   echo "$as_me:$LINENO: result: no" >&5
9087 echo "${ECHO_T}no" >&6
9088 fi
9089
9090     fi
9091     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9092       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9093 set dummy ${ncn_progname}; ac_word=$2
9094 echo "$as_me:$LINENO: checking for $ac_word" >&5
9095 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9096 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9097   echo $ECHO_N "(cached) $ECHO_C" >&6
9098 else
9099   if test -n "$AR_FOR_TARGET"; then
9100   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9101 else
9102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9103 for as_dir in $PATH
9104 do
9105   IFS=$as_save_IFS
9106   test -z "$as_dir" && as_dir=.
9107   for ac_exec_ext in '' $ac_executable_extensions; do
9108   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9109     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9110     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9111     break 2
9112   fi
9113 done
9114 done
9115
9116 fi
9117 fi
9118 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9119 if test -n "$AR_FOR_TARGET"; then
9120   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9121 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9122 else
9123   echo "$as_me:$LINENO: result: no" >&5
9124 echo "${ECHO_T}no" >&6
9125 fi
9126
9127     fi
9128     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9129   done
9130 fi
9131
9132 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9133   set dummy ar
9134   if test $build = $target ; then
9135     AR_FOR_TARGET="$2"
9136   else
9137     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9138   fi
9139 else
9140   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9141 fi
9142
9143 else
9144   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9145 fi
9146
9147
9148
9149
9150 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9151   if test -n "$with_build_time_tools"; then
9152     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9153 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9154     if test -x $with_build_time_tools/as; then
9155       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9156       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9157       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9158 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9159     else
9160       echo "$as_me:$LINENO: result: no" >&5
9161 echo "${ECHO_T}no" >&6
9162     fi
9163   elif test $build != $host && test $have_gcc_for_target = yes; then
9164     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9165     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9166     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9167   fi
9168 fi
9169 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9170   # Extract the first word of "as", so it can be a program name with args.
9171 set dummy as; ac_word=$2
9172 echo "$as_me:$LINENO: checking for $ac_word" >&5
9173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9174 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9175   echo $ECHO_N "(cached) $ECHO_C" >&6
9176 else
9177   case $AS_FOR_TARGET in
9178   [\\/]* | ?:[\\/]*)
9179   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9180   ;;
9181   *)
9182   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9183 for as_dir in $gcc_cv_tool_dirs
9184 do
9185   IFS=$as_save_IFS
9186   test -z "$as_dir" && as_dir=.
9187   for ac_exec_ext in '' $ac_executable_extensions; do
9188   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9189     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9190     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9191     break 2
9192   fi
9193 done
9194 done
9195
9196   ;;
9197 esac
9198 fi
9199 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9200
9201 if test -n "$AS_FOR_TARGET"; then
9202   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9203 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9204 else
9205   echo "$as_me:$LINENO: result: no" >&5
9206 echo "${ECHO_T}no" >&6
9207 fi
9208
9209 fi
9210 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9211
9212
9213 if test -n "$AS_FOR_TARGET"; then
9214   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9215 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9216   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9217 fi
9218
9219 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9220   for ncn_progname in as; do
9221     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9222 set dummy ${ncn_progname}; ac_word=$2
9223 echo "$as_me:$LINENO: checking for $ac_word" >&5
9224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9225 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9226   echo $ECHO_N "(cached) $ECHO_C" >&6
9227 else
9228   if test -n "$AS_FOR_TARGET"; then
9229   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9230 else
9231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9232 for as_dir in $PATH
9233 do
9234   IFS=$as_save_IFS
9235   test -z "$as_dir" && as_dir=.
9236   for ac_exec_ext in '' $ac_executable_extensions; do
9237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9238     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9240     break 2
9241   fi
9242 done
9243 done
9244
9245 fi
9246 fi
9247 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9248 if test -n "$AS_FOR_TARGET"; then
9249   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9250 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9251 else
9252   echo "$as_me:$LINENO: result: no" >&5
9253 echo "${ECHO_T}no" >&6
9254 fi
9255
9256   done
9257 fi
9258
9259 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9260   for ncn_progname in as; do
9261     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9262 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9263     if test -x $with_build_time_tools/${ncn_progname}; then
9264       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9265       echo "$as_me:$LINENO: result: yes" >&5
9266 echo "${ECHO_T}yes" >&6
9267       break
9268     else
9269       echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271     fi
9272   done
9273 fi
9274
9275 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9276   for ncn_progname in as; do
9277     if test -n "$ncn_target_tool_prefix"; then
9278       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9279 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9280 echo "$as_me:$LINENO: checking for $ac_word" >&5
9281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9282 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9283   echo $ECHO_N "(cached) $ECHO_C" >&6
9284 else
9285   if test -n "$AS_FOR_TARGET"; then
9286   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9287 else
9288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9289 for as_dir in $PATH
9290 do
9291   IFS=$as_save_IFS
9292   test -z "$as_dir" && as_dir=.
9293   for ac_exec_ext in '' $ac_executable_extensions; do
9294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9295     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9297     break 2
9298   fi
9299 done
9300 done
9301
9302 fi
9303 fi
9304 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9305 if test -n "$AS_FOR_TARGET"; then
9306   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9307 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9308 else
9309   echo "$as_me:$LINENO: result: no" >&5
9310 echo "${ECHO_T}no" >&6
9311 fi
9312
9313     fi
9314     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9315       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9316 set dummy ${ncn_progname}; ac_word=$2
9317 echo "$as_me:$LINENO: checking for $ac_word" >&5
9318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9319 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9320   echo $ECHO_N "(cached) $ECHO_C" >&6
9321 else
9322   if test -n "$AS_FOR_TARGET"; then
9323   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9324 else
9325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9326 for as_dir in $PATH
9327 do
9328   IFS=$as_save_IFS
9329   test -z "$as_dir" && as_dir=.
9330   for ac_exec_ext in '' $ac_executable_extensions; do
9331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9332     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9334     break 2
9335   fi
9336 done
9337 done
9338
9339 fi
9340 fi
9341 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9342 if test -n "$AS_FOR_TARGET"; then
9343   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9344 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9345 else
9346   echo "$as_me:$LINENO: result: no" >&5
9347 echo "${ECHO_T}no" >&6
9348 fi
9349
9350     fi
9351     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9352   done
9353 fi
9354
9355 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9356   set dummy as
9357   if test $build = $target ; then
9358     AS_FOR_TARGET="$2"
9359   else
9360     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9361   fi
9362 else
9363   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9364 fi
9365
9366 else
9367   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9368 fi
9369
9370
9371
9372
9373 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9374   if test -n "$with_build_time_tools"; then
9375     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9376 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9377     if test -x $with_build_time_tools/dlltool; then
9378       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9379       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9380       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9381 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9382     else
9383       echo "$as_me:$LINENO: result: no" >&5
9384 echo "${ECHO_T}no" >&6
9385     fi
9386   elif test $build != $host && test $have_gcc_for_target = yes; then
9387     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9388     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9389     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9390   fi
9391 fi
9392 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9393   # Extract the first word of "dlltool", so it can be a program name with args.
9394 set dummy dlltool; ac_word=$2
9395 echo "$as_me:$LINENO: checking for $ac_word" >&5
9396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9397 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9398   echo $ECHO_N "(cached) $ECHO_C" >&6
9399 else
9400   case $DLLTOOL_FOR_TARGET in
9401   [\\/]* | ?:[\\/]*)
9402   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9403   ;;
9404   *)
9405   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9406 for as_dir in $gcc_cv_tool_dirs
9407 do
9408   IFS=$as_save_IFS
9409   test -z "$as_dir" && as_dir=.
9410   for ac_exec_ext in '' $ac_executable_extensions; do
9411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9412     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9414     break 2
9415   fi
9416 done
9417 done
9418
9419   ;;
9420 esac
9421 fi
9422 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9423
9424 if test -n "$DLLTOOL_FOR_TARGET"; then
9425   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9426 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9427 else
9428   echo "$as_me:$LINENO: result: no" >&5
9429 echo "${ECHO_T}no" >&6
9430 fi
9431
9432 fi
9433 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9434
9435
9436 if test -n "$DLLTOOL_FOR_TARGET"; then
9437   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9438 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9439   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9440 fi
9441
9442 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9443   for ncn_progname in dlltool; do
9444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9445 set dummy ${ncn_progname}; ac_word=$2
9446 echo "$as_me:$LINENO: checking for $ac_word" >&5
9447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9448 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9449   echo $ECHO_N "(cached) $ECHO_C" >&6
9450 else
9451   if test -n "$DLLTOOL_FOR_TARGET"; then
9452   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9453 else
9454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9455 for as_dir in $PATH
9456 do
9457   IFS=$as_save_IFS
9458   test -z "$as_dir" && as_dir=.
9459   for ac_exec_ext in '' $ac_executable_extensions; do
9460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9461     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9463     break 2
9464   fi
9465 done
9466 done
9467
9468 fi
9469 fi
9470 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9471 if test -n "$DLLTOOL_FOR_TARGET"; then
9472   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9473 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9474 else
9475   echo "$as_me:$LINENO: result: no" >&5
9476 echo "${ECHO_T}no" >&6
9477 fi
9478
9479   done
9480 fi
9481
9482 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9483   for ncn_progname in dlltool; do
9484     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9485 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9486     if test -x $with_build_time_tools/${ncn_progname}; then
9487       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9488       echo "$as_me:$LINENO: result: yes" >&5
9489 echo "${ECHO_T}yes" >&6
9490       break
9491     else
9492       echo "$as_me:$LINENO: result: no" >&5
9493 echo "${ECHO_T}no" >&6
9494     fi
9495   done
9496 fi
9497
9498 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9499   for ncn_progname in dlltool; do
9500     if test -n "$ncn_target_tool_prefix"; then
9501       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9502 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9503 echo "$as_me:$LINENO: checking for $ac_word" >&5
9504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9505 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9506   echo $ECHO_N "(cached) $ECHO_C" >&6
9507 else
9508   if test -n "$DLLTOOL_FOR_TARGET"; then
9509   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9510 else
9511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9512 for as_dir in $PATH
9513 do
9514   IFS=$as_save_IFS
9515   test -z "$as_dir" && as_dir=.
9516   for ac_exec_ext in '' $ac_executable_extensions; do
9517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9518     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9520     break 2
9521   fi
9522 done
9523 done
9524
9525 fi
9526 fi
9527 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9528 if test -n "$DLLTOOL_FOR_TARGET"; then
9529   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9530 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9531 else
9532   echo "$as_me:$LINENO: result: no" >&5
9533 echo "${ECHO_T}no" >&6
9534 fi
9535
9536     fi
9537     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9538       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9539 set dummy ${ncn_progname}; ac_word=$2
9540 echo "$as_me:$LINENO: checking for $ac_word" >&5
9541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9542 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9543   echo $ECHO_N "(cached) $ECHO_C" >&6
9544 else
9545   if test -n "$DLLTOOL_FOR_TARGET"; then
9546   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9547 else
9548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9549 for as_dir in $PATH
9550 do
9551   IFS=$as_save_IFS
9552   test -z "$as_dir" && as_dir=.
9553   for ac_exec_ext in '' $ac_executable_extensions; do
9554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9555     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9557     break 2
9558   fi
9559 done
9560 done
9561
9562 fi
9563 fi
9564 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9565 if test -n "$DLLTOOL_FOR_TARGET"; then
9566   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9567 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9568 else
9569   echo "$as_me:$LINENO: result: no" >&5
9570 echo "${ECHO_T}no" >&6
9571 fi
9572
9573     fi
9574     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9575   done
9576 fi
9577
9578 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9579   set dummy dlltool
9580   if test $build = $target ; then
9581     DLLTOOL_FOR_TARGET="$2"
9582   else
9583     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9584   fi
9585 else
9586   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9587 fi
9588
9589 else
9590   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9591 fi
9592
9593
9594
9595
9596 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9597   if test -n "$with_build_time_tools"; then
9598     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9599 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9600     if test -x $with_build_time_tools/ld; then
9601       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9602       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9603       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9604 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9605     else
9606       echo "$as_me:$LINENO: result: no" >&5
9607 echo "${ECHO_T}no" >&6
9608     fi
9609   elif test $build != $host && test $have_gcc_for_target = yes; then
9610     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9611     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9612     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9613   fi
9614 fi
9615 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9616   # Extract the first word of "ld", so it can be a program name with args.
9617 set dummy ld; ac_word=$2
9618 echo "$as_me:$LINENO: checking for $ac_word" >&5
9619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9620 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9621   echo $ECHO_N "(cached) $ECHO_C" >&6
9622 else
9623   case $LD_FOR_TARGET in
9624   [\\/]* | ?:[\\/]*)
9625   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9626   ;;
9627   *)
9628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9629 for as_dir in $gcc_cv_tool_dirs
9630 do
9631   IFS=$as_save_IFS
9632   test -z "$as_dir" && as_dir=.
9633   for ac_exec_ext in '' $ac_executable_extensions; do
9634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9635     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9637     break 2
9638   fi
9639 done
9640 done
9641
9642   ;;
9643 esac
9644 fi
9645 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9646
9647 if test -n "$LD_FOR_TARGET"; then
9648   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9649 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9650 else
9651   echo "$as_me:$LINENO: result: no" >&5
9652 echo "${ECHO_T}no" >&6
9653 fi
9654
9655 fi
9656 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9657
9658
9659 if test -n "$LD_FOR_TARGET"; then
9660   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9661 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9662   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9663 fi
9664
9665 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9666   for ncn_progname in ld; do
9667     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9668 set dummy ${ncn_progname}; ac_word=$2
9669 echo "$as_me:$LINENO: checking for $ac_word" >&5
9670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9671 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9672   echo $ECHO_N "(cached) $ECHO_C" >&6
9673 else
9674   if test -n "$LD_FOR_TARGET"; then
9675   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9676 else
9677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9678 for as_dir in $PATH
9679 do
9680   IFS=$as_save_IFS
9681   test -z "$as_dir" && as_dir=.
9682   for ac_exec_ext in '' $ac_executable_extensions; do
9683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9684     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9686     break 2
9687   fi
9688 done
9689 done
9690
9691 fi
9692 fi
9693 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9694 if test -n "$LD_FOR_TARGET"; then
9695   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9696 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9697 else
9698   echo "$as_me:$LINENO: result: no" >&5
9699 echo "${ECHO_T}no" >&6
9700 fi
9701
9702   done
9703 fi
9704
9705 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9706   for ncn_progname in ld; do
9707     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9708 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9709     if test -x $with_build_time_tools/${ncn_progname}; then
9710       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9711       echo "$as_me:$LINENO: result: yes" >&5
9712 echo "${ECHO_T}yes" >&6
9713       break
9714     else
9715       echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717     fi
9718   done
9719 fi
9720
9721 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9722   for ncn_progname in ld; do
9723     if test -n "$ncn_target_tool_prefix"; then
9724       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9725 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9726 echo "$as_me:$LINENO: checking for $ac_word" >&5
9727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9728 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9729   echo $ECHO_N "(cached) $ECHO_C" >&6
9730 else
9731   if test -n "$LD_FOR_TARGET"; then
9732   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9733 else
9734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9735 for as_dir in $PATH
9736 do
9737   IFS=$as_save_IFS
9738   test -z "$as_dir" && as_dir=.
9739   for ac_exec_ext in '' $ac_executable_extensions; do
9740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9741     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9743     break 2
9744   fi
9745 done
9746 done
9747
9748 fi
9749 fi
9750 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9751 if test -n "$LD_FOR_TARGET"; then
9752   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9753 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9754 else
9755   echo "$as_me:$LINENO: result: no" >&5
9756 echo "${ECHO_T}no" >&6
9757 fi
9758
9759     fi
9760     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9761       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9762 set dummy ${ncn_progname}; ac_word=$2
9763 echo "$as_me:$LINENO: checking for $ac_word" >&5
9764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9765 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9766   echo $ECHO_N "(cached) $ECHO_C" >&6
9767 else
9768   if test -n "$LD_FOR_TARGET"; then
9769   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9770 else
9771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9772 for as_dir in $PATH
9773 do
9774   IFS=$as_save_IFS
9775   test -z "$as_dir" && as_dir=.
9776   for ac_exec_ext in '' $ac_executable_extensions; do
9777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9778     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9780     break 2
9781   fi
9782 done
9783 done
9784
9785 fi
9786 fi
9787 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9788 if test -n "$LD_FOR_TARGET"; then
9789   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9790 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9791 else
9792   echo "$as_me:$LINENO: result: no" >&5
9793 echo "${ECHO_T}no" >&6
9794 fi
9795
9796     fi
9797     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9798   done
9799 fi
9800
9801 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9802   set dummy ld
9803   if test $build = $target ; then
9804     LD_FOR_TARGET="$2"
9805   else
9806     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9807   fi
9808 else
9809   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9810 fi
9811
9812 else
9813   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9814 fi
9815
9816
9817
9818
9819 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9820   if test -n "$with_build_time_tools"; then
9821     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9822 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9823     if test -x $with_build_time_tools/lipo; then
9824       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9825       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9826       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9827 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9828     else
9829       echo "$as_me:$LINENO: result: no" >&5
9830 echo "${ECHO_T}no" >&6
9831     fi
9832   elif test $build != $host && test $have_gcc_for_target = yes; then
9833     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9834     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9835     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9836   fi
9837 fi
9838 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9839   # Extract the first word of "lipo", so it can be a program name with args.
9840 set dummy lipo; ac_word=$2
9841 echo "$as_me:$LINENO: checking for $ac_word" >&5
9842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9843 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9844   echo $ECHO_N "(cached) $ECHO_C" >&6
9845 else
9846   case $LIPO_FOR_TARGET in
9847   [\\/]* | ?:[\\/]*)
9848   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9849   ;;
9850   *)
9851   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9852 for as_dir in $gcc_cv_tool_dirs
9853 do
9854   IFS=$as_save_IFS
9855   test -z "$as_dir" && as_dir=.
9856   for ac_exec_ext in '' $ac_executable_extensions; do
9857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9858     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9860     break 2
9861   fi
9862 done
9863 done
9864
9865   ;;
9866 esac
9867 fi
9868 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9869
9870 if test -n "$LIPO_FOR_TARGET"; then
9871   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9872 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9873 else
9874   echo "$as_me:$LINENO: result: no" >&5
9875 echo "${ECHO_T}no" >&6
9876 fi
9877
9878 fi
9879 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9880
9881
9882 if test -n "$LIPO_FOR_TARGET"; then
9883   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9884 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9885   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9886 fi
9887
9888 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9889   for ncn_progname in lipo; do
9890     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9891 set dummy ${ncn_progname}; ac_word=$2
9892 echo "$as_me:$LINENO: checking for $ac_word" >&5
9893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9894 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9895   echo $ECHO_N "(cached) $ECHO_C" >&6
9896 else
9897   if test -n "$LIPO_FOR_TARGET"; then
9898   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9899 else
9900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9901 for as_dir in $PATH
9902 do
9903   IFS=$as_save_IFS
9904   test -z "$as_dir" && as_dir=.
9905   for ac_exec_ext in '' $ac_executable_extensions; do
9906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9907     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9909     break 2
9910   fi
9911 done
9912 done
9913
9914 fi
9915 fi
9916 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9917 if test -n "$LIPO_FOR_TARGET"; then
9918   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9919 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9920 else
9921   echo "$as_me:$LINENO: result: no" >&5
9922 echo "${ECHO_T}no" >&6
9923 fi
9924
9925   done
9926 fi
9927
9928 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9929   for ncn_progname in lipo; do
9930     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9931 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9932     if test -x $with_build_time_tools/${ncn_progname}; then
9933       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9934       echo "$as_me:$LINENO: result: yes" >&5
9935 echo "${ECHO_T}yes" >&6
9936       break
9937     else
9938       echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940     fi
9941   done
9942 fi
9943
9944 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9945   for ncn_progname in lipo; do
9946     if test -n "$ncn_target_tool_prefix"; then
9947       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9948 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9949 echo "$as_me:$LINENO: checking for $ac_word" >&5
9950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9951 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9952   echo $ECHO_N "(cached) $ECHO_C" >&6
9953 else
9954   if test -n "$LIPO_FOR_TARGET"; then
9955   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9956 else
9957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9958 for as_dir in $PATH
9959 do
9960   IFS=$as_save_IFS
9961   test -z "$as_dir" && as_dir=.
9962   for ac_exec_ext in '' $ac_executable_extensions; do
9963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9964     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9966     break 2
9967   fi
9968 done
9969 done
9970
9971 fi
9972 fi
9973 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9974 if test -n "$LIPO_FOR_TARGET"; then
9975   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9976 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9977 else
9978   echo "$as_me:$LINENO: result: no" >&5
9979 echo "${ECHO_T}no" >&6
9980 fi
9981
9982     fi
9983     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9984       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9985 set dummy ${ncn_progname}; ac_word=$2
9986 echo "$as_me:$LINENO: checking for $ac_word" >&5
9987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9988 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9989   echo $ECHO_N "(cached) $ECHO_C" >&6
9990 else
9991   if test -n "$LIPO_FOR_TARGET"; then
9992   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9993 else
9994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9995 for as_dir in $PATH
9996 do
9997   IFS=$as_save_IFS
9998   test -z "$as_dir" && as_dir=.
9999   for ac_exec_ext in '' $ac_executable_extensions; do
10000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10001     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10003     break 2
10004   fi
10005 done
10006 done
10007
10008 fi
10009 fi
10010 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10011 if test -n "$LIPO_FOR_TARGET"; then
10012   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10013 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10014 else
10015   echo "$as_me:$LINENO: result: no" >&5
10016 echo "${ECHO_T}no" >&6
10017 fi
10018
10019     fi
10020     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10021   done
10022 fi
10023
10024 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10025   set dummy lipo
10026   if test $build = $target ; then
10027     LIPO_FOR_TARGET="$2"
10028   else
10029     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10030   fi
10031 else
10032   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10033 fi
10034
10035 else
10036   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10037 fi
10038
10039
10040
10041
10042 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10043   if test -n "$with_build_time_tools"; then
10044     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10045 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10046     if test -x $with_build_time_tools/nm; then
10047       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10048       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10049       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10050 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10051     else
10052       echo "$as_me:$LINENO: result: no" >&5
10053 echo "${ECHO_T}no" >&6
10054     fi
10055   elif test $build != $host && test $have_gcc_for_target = yes; then
10056     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10057     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10058     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10059   fi
10060 fi
10061 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10062   # Extract the first word of "nm", so it can be a program name with args.
10063 set dummy nm; ac_word=$2
10064 echo "$as_me:$LINENO: checking for $ac_word" >&5
10065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10066 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10067   echo $ECHO_N "(cached) $ECHO_C" >&6
10068 else
10069   case $NM_FOR_TARGET in
10070   [\\/]* | ?:[\\/]*)
10071   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10072   ;;
10073   *)
10074   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10075 for as_dir in $gcc_cv_tool_dirs
10076 do
10077   IFS=$as_save_IFS
10078   test -z "$as_dir" && as_dir=.
10079   for ac_exec_ext in '' $ac_executable_extensions; do
10080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10081     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10083     break 2
10084   fi
10085 done
10086 done
10087
10088   ;;
10089 esac
10090 fi
10091 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10092
10093 if test -n "$NM_FOR_TARGET"; then
10094   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10095 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10096 else
10097   echo "$as_me:$LINENO: result: no" >&5
10098 echo "${ECHO_T}no" >&6
10099 fi
10100
10101 fi
10102 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10103
10104
10105 if test -n "$NM_FOR_TARGET"; then
10106   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10107 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10108   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10109 fi
10110
10111 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10112   for ncn_progname in nm; do
10113     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10114 set dummy ${ncn_progname}; ac_word=$2
10115 echo "$as_me:$LINENO: checking for $ac_word" >&5
10116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10117 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10118   echo $ECHO_N "(cached) $ECHO_C" >&6
10119 else
10120   if test -n "$NM_FOR_TARGET"; then
10121   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10122 else
10123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10124 for as_dir in $PATH
10125 do
10126   IFS=$as_save_IFS
10127   test -z "$as_dir" && as_dir=.
10128   for ac_exec_ext in '' $ac_executable_extensions; do
10129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10130     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10132     break 2
10133   fi
10134 done
10135 done
10136
10137 fi
10138 fi
10139 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10140 if test -n "$NM_FOR_TARGET"; then
10141   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10142 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10143 else
10144   echo "$as_me:$LINENO: result: no" >&5
10145 echo "${ECHO_T}no" >&6
10146 fi
10147
10148   done
10149 fi
10150
10151 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10152   for ncn_progname in nm; do
10153     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10154 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10155     if test -x $with_build_time_tools/${ncn_progname}; then
10156       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10157       echo "$as_me:$LINENO: result: yes" >&5
10158 echo "${ECHO_T}yes" >&6
10159       break
10160     else
10161       echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163     fi
10164   done
10165 fi
10166
10167 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10168   for ncn_progname in nm; do
10169     if test -n "$ncn_target_tool_prefix"; then
10170       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10171 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10172 echo "$as_me:$LINENO: checking for $ac_word" >&5
10173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10174 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10175   echo $ECHO_N "(cached) $ECHO_C" >&6
10176 else
10177   if test -n "$NM_FOR_TARGET"; then
10178   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10179 else
10180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10181 for as_dir in $PATH
10182 do
10183   IFS=$as_save_IFS
10184   test -z "$as_dir" && as_dir=.
10185   for ac_exec_ext in '' $ac_executable_extensions; do
10186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10187     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10189     break 2
10190   fi
10191 done
10192 done
10193
10194 fi
10195 fi
10196 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10197 if test -n "$NM_FOR_TARGET"; then
10198   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10199 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10200 else
10201   echo "$as_me:$LINENO: result: no" >&5
10202 echo "${ECHO_T}no" >&6
10203 fi
10204
10205     fi
10206     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10207       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10208 set dummy ${ncn_progname}; ac_word=$2
10209 echo "$as_me:$LINENO: checking for $ac_word" >&5
10210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10211 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10212   echo $ECHO_N "(cached) $ECHO_C" >&6
10213 else
10214   if test -n "$NM_FOR_TARGET"; then
10215   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10216 else
10217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10218 for as_dir in $PATH
10219 do
10220   IFS=$as_save_IFS
10221   test -z "$as_dir" && as_dir=.
10222   for ac_exec_ext in '' $ac_executable_extensions; do
10223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10224     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10226     break 2
10227   fi
10228 done
10229 done
10230
10231 fi
10232 fi
10233 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10234 if test -n "$NM_FOR_TARGET"; then
10235   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10236 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10237 else
10238   echo "$as_me:$LINENO: result: no" >&5
10239 echo "${ECHO_T}no" >&6
10240 fi
10241
10242     fi
10243     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10244   done
10245 fi
10246
10247 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10248   set dummy nm
10249   if test $build = $target ; then
10250     NM_FOR_TARGET="$2"
10251   else
10252     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10253   fi
10254 else
10255   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10256 fi
10257
10258 else
10259   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10260 fi
10261
10262
10263
10264
10265 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10266   if test -n "$with_build_time_tools"; then
10267     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10268 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10269     if test -x $with_build_time_tools/objdump; then
10270       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10271       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10272       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10273 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10274     else
10275       echo "$as_me:$LINENO: result: no" >&5
10276 echo "${ECHO_T}no" >&6
10277     fi
10278   elif test $build != $host && test $have_gcc_for_target = yes; then
10279     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10280     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10281     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10282   fi
10283 fi
10284 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10285   # Extract the first word of "objdump", so it can be a program name with args.
10286 set dummy objdump; ac_word=$2
10287 echo "$as_me:$LINENO: checking for $ac_word" >&5
10288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10289 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10290   echo $ECHO_N "(cached) $ECHO_C" >&6
10291 else
10292   case $OBJDUMP_FOR_TARGET in
10293   [\\/]* | ?:[\\/]*)
10294   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10295   ;;
10296   *)
10297   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10298 for as_dir in $gcc_cv_tool_dirs
10299 do
10300   IFS=$as_save_IFS
10301   test -z "$as_dir" && as_dir=.
10302   for ac_exec_ext in '' $ac_executable_extensions; do
10303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10304     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10306     break 2
10307   fi
10308 done
10309 done
10310
10311   ;;
10312 esac
10313 fi
10314 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10315
10316 if test -n "$OBJDUMP_FOR_TARGET"; then
10317   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10318 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10319 else
10320   echo "$as_me:$LINENO: result: no" >&5
10321 echo "${ECHO_T}no" >&6
10322 fi
10323
10324 fi
10325 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10326
10327
10328 if test -n "$OBJDUMP_FOR_TARGET"; then
10329   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10330 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10331   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10332 fi
10333
10334 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10335   for ncn_progname in objdump; do
10336     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10337 set dummy ${ncn_progname}; ac_word=$2
10338 echo "$as_me:$LINENO: checking for $ac_word" >&5
10339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10340 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10341   echo $ECHO_N "(cached) $ECHO_C" >&6
10342 else
10343   if test -n "$OBJDUMP_FOR_TARGET"; then
10344   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10345 else
10346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10347 for as_dir in $PATH
10348 do
10349   IFS=$as_save_IFS
10350   test -z "$as_dir" && as_dir=.
10351   for ac_exec_ext in '' $ac_executable_extensions; do
10352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10353     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10355     break 2
10356   fi
10357 done
10358 done
10359
10360 fi
10361 fi
10362 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10363 if test -n "$OBJDUMP_FOR_TARGET"; then
10364   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10365 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10366 else
10367   echo "$as_me:$LINENO: result: no" >&5
10368 echo "${ECHO_T}no" >&6
10369 fi
10370
10371   done
10372 fi
10373
10374 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10375   for ncn_progname in objdump; do
10376     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10377 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10378     if test -x $with_build_time_tools/${ncn_progname}; then
10379       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10380       echo "$as_me:$LINENO: result: yes" >&5
10381 echo "${ECHO_T}yes" >&6
10382       break
10383     else
10384       echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386     fi
10387   done
10388 fi
10389
10390 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10391   for ncn_progname in objdump; do
10392     if test -n "$ncn_target_tool_prefix"; then
10393       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10394 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10395 echo "$as_me:$LINENO: checking for $ac_word" >&5
10396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10397 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10398   echo $ECHO_N "(cached) $ECHO_C" >&6
10399 else
10400   if test -n "$OBJDUMP_FOR_TARGET"; then
10401   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10402 else
10403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 for as_dir in $PATH
10405 do
10406   IFS=$as_save_IFS
10407   test -z "$as_dir" && as_dir=.
10408   for ac_exec_ext in '' $ac_executable_extensions; do
10409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10412     break 2
10413   fi
10414 done
10415 done
10416
10417 fi
10418 fi
10419 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10420 if test -n "$OBJDUMP_FOR_TARGET"; then
10421   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10422 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10423 else
10424   echo "$as_me:$LINENO: result: no" >&5
10425 echo "${ECHO_T}no" >&6
10426 fi
10427
10428     fi
10429     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10430       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10431 set dummy ${ncn_progname}; ac_word=$2
10432 echo "$as_me:$LINENO: checking for $ac_word" >&5
10433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10434 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10435   echo $ECHO_N "(cached) $ECHO_C" >&6
10436 else
10437   if test -n "$OBJDUMP_FOR_TARGET"; then
10438   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10439 else
10440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10441 for as_dir in $PATH
10442 do
10443   IFS=$as_save_IFS
10444   test -z "$as_dir" && as_dir=.
10445   for ac_exec_ext in '' $ac_executable_extensions; do
10446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10447     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10449     break 2
10450   fi
10451 done
10452 done
10453
10454 fi
10455 fi
10456 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10457 if test -n "$OBJDUMP_FOR_TARGET"; then
10458   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10459 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10460 else
10461   echo "$as_me:$LINENO: result: no" >&5
10462 echo "${ECHO_T}no" >&6
10463 fi
10464
10465     fi
10466     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10467   done
10468 fi
10469
10470 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10471   set dummy objdump
10472   if test $build = $target ; then
10473     OBJDUMP_FOR_TARGET="$2"
10474   else
10475     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10476   fi
10477 else
10478   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10479 fi
10480
10481 else
10482   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10483 fi
10484
10485
10486
10487
10488 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10489   if test -n "$with_build_time_tools"; then
10490     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10491 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10492     if test -x $with_build_time_tools/ranlib; then
10493       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10494       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10495       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10496 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10497     else
10498       echo "$as_me:$LINENO: result: no" >&5
10499 echo "${ECHO_T}no" >&6
10500     fi
10501   elif test $build != $host && test $have_gcc_for_target = yes; then
10502     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10503     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10504     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10505   fi
10506 fi
10507 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10508   # Extract the first word of "ranlib", so it can be a program name with args.
10509 set dummy ranlib; ac_word=$2
10510 echo "$as_me:$LINENO: checking for $ac_word" >&5
10511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10512 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10513   echo $ECHO_N "(cached) $ECHO_C" >&6
10514 else
10515   case $RANLIB_FOR_TARGET in
10516   [\\/]* | ?:[\\/]*)
10517   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10518   ;;
10519   *)
10520   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10521 for as_dir in $gcc_cv_tool_dirs
10522 do
10523   IFS=$as_save_IFS
10524   test -z "$as_dir" && as_dir=.
10525   for ac_exec_ext in '' $ac_executable_extensions; do
10526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10527     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10529     break 2
10530   fi
10531 done
10532 done
10533
10534   ;;
10535 esac
10536 fi
10537 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10538
10539 if test -n "$RANLIB_FOR_TARGET"; then
10540   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10541 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10542 else
10543   echo "$as_me:$LINENO: result: no" >&5
10544 echo "${ECHO_T}no" >&6
10545 fi
10546
10547 fi
10548 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10549
10550
10551 if test -n "$RANLIB_FOR_TARGET"; then
10552   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10553 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10554   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10555 fi
10556
10557 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10558   for ncn_progname in ranlib; do
10559     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10560 set dummy ${ncn_progname}; ac_word=$2
10561 echo "$as_me:$LINENO: checking for $ac_word" >&5
10562 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10563 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10564   echo $ECHO_N "(cached) $ECHO_C" >&6
10565 else
10566   if test -n "$RANLIB_FOR_TARGET"; then
10567   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10568 else
10569 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10570 for as_dir in $PATH
10571 do
10572   IFS=$as_save_IFS
10573   test -z "$as_dir" && as_dir=.
10574   for ac_exec_ext in '' $ac_executable_extensions; do
10575   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10576     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10577     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10578     break 2
10579   fi
10580 done
10581 done
10582
10583 fi
10584 fi
10585 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10586 if test -n "$RANLIB_FOR_TARGET"; then
10587   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10588 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10589 else
10590   echo "$as_me:$LINENO: result: no" >&5
10591 echo "${ECHO_T}no" >&6
10592 fi
10593
10594   done
10595 fi
10596
10597 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10598   for ncn_progname in ranlib; do
10599     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10600 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10601     if test -x $with_build_time_tools/${ncn_progname}; then
10602       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10603       echo "$as_me:$LINENO: result: yes" >&5
10604 echo "${ECHO_T}yes" >&6
10605       break
10606     else
10607       echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609     fi
10610   done
10611 fi
10612
10613 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10614   for ncn_progname in ranlib; do
10615     if test -n "$ncn_target_tool_prefix"; then
10616       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10617 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10618 echo "$as_me:$LINENO: checking for $ac_word" >&5
10619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10620 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10621   echo $ECHO_N "(cached) $ECHO_C" >&6
10622 else
10623   if test -n "$RANLIB_FOR_TARGET"; then
10624   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10625 else
10626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10627 for as_dir in $PATH
10628 do
10629   IFS=$as_save_IFS
10630   test -z "$as_dir" && as_dir=.
10631   for ac_exec_ext in '' $ac_executable_extensions; do
10632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10633     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10635     break 2
10636   fi
10637 done
10638 done
10639
10640 fi
10641 fi
10642 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10643 if test -n "$RANLIB_FOR_TARGET"; then
10644   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10645 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10646 else
10647   echo "$as_me:$LINENO: result: no" >&5
10648 echo "${ECHO_T}no" >&6
10649 fi
10650
10651     fi
10652     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10653       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10654 set dummy ${ncn_progname}; ac_word=$2
10655 echo "$as_me:$LINENO: checking for $ac_word" >&5
10656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10657 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10658   echo $ECHO_N "(cached) $ECHO_C" >&6
10659 else
10660   if test -n "$RANLIB_FOR_TARGET"; then
10661   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10662 else
10663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10664 for as_dir in $PATH
10665 do
10666   IFS=$as_save_IFS
10667   test -z "$as_dir" && as_dir=.
10668   for ac_exec_ext in '' $ac_executable_extensions; do
10669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10670     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10672     break 2
10673   fi
10674 done
10675 done
10676
10677 fi
10678 fi
10679 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10680 if test -n "$RANLIB_FOR_TARGET"; then
10681   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10682 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10683 else
10684   echo "$as_me:$LINENO: result: no" >&5
10685 echo "${ECHO_T}no" >&6
10686 fi
10687
10688     fi
10689     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10690   done
10691 fi
10692
10693 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10694   set dummy ranlib
10695   if test $build = $target ; then
10696     RANLIB_FOR_TARGET="$2"
10697   else
10698     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10699   fi
10700 else
10701   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10702 fi
10703
10704 else
10705   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10706 fi
10707
10708
10709
10710
10711 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10712   if test -n "$with_build_time_tools"; then
10713     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10714 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10715     if test -x $with_build_time_tools/strip; then
10716       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10717       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10718       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10719 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10720     else
10721       echo "$as_me:$LINENO: result: no" >&5
10722 echo "${ECHO_T}no" >&6
10723     fi
10724   elif test $build != $host && test $have_gcc_for_target = yes; then
10725     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10726     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10727     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10728   fi
10729 fi
10730 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10731   # Extract the first word of "strip", so it can be a program name with args.
10732 set dummy strip; ac_word=$2
10733 echo "$as_me:$LINENO: checking for $ac_word" >&5
10734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10735 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10736   echo $ECHO_N "(cached) $ECHO_C" >&6
10737 else
10738   case $STRIP_FOR_TARGET in
10739   [\\/]* | ?:[\\/]*)
10740   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10741   ;;
10742   *)
10743   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10744 for as_dir in $gcc_cv_tool_dirs
10745 do
10746   IFS=$as_save_IFS
10747   test -z "$as_dir" && as_dir=.
10748   for ac_exec_ext in '' $ac_executable_extensions; do
10749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10750     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10752     break 2
10753   fi
10754 done
10755 done
10756
10757   ;;
10758 esac
10759 fi
10760 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10761
10762 if test -n "$STRIP_FOR_TARGET"; then
10763   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10764 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10765 else
10766   echo "$as_me:$LINENO: result: no" >&5
10767 echo "${ECHO_T}no" >&6
10768 fi
10769
10770 fi
10771 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10772
10773
10774 if test -n "$STRIP_FOR_TARGET"; then
10775   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10776 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10777   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10778 fi
10779
10780 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10781   for ncn_progname in strip; do
10782     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10783 set dummy ${ncn_progname}; ac_word=$2
10784 echo "$as_me:$LINENO: checking for $ac_word" >&5
10785 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10786 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10787   echo $ECHO_N "(cached) $ECHO_C" >&6
10788 else
10789   if test -n "$STRIP_FOR_TARGET"; then
10790   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10791 else
10792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10793 for as_dir in $PATH
10794 do
10795   IFS=$as_save_IFS
10796   test -z "$as_dir" && as_dir=.
10797   for ac_exec_ext in '' $ac_executable_extensions; do
10798   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10799     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10800     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10801     break 2
10802   fi
10803 done
10804 done
10805
10806 fi
10807 fi
10808 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10809 if test -n "$STRIP_FOR_TARGET"; then
10810   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10811 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10812 else
10813   echo "$as_me:$LINENO: result: no" >&5
10814 echo "${ECHO_T}no" >&6
10815 fi
10816
10817   done
10818 fi
10819
10820 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10821   for ncn_progname in strip; do
10822     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10823 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10824     if test -x $with_build_time_tools/${ncn_progname}; then
10825       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10826       echo "$as_me:$LINENO: result: yes" >&5
10827 echo "${ECHO_T}yes" >&6
10828       break
10829     else
10830       echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832     fi
10833   done
10834 fi
10835
10836 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10837   for ncn_progname in strip; do
10838     if test -n "$ncn_target_tool_prefix"; then
10839       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10840 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10841 echo "$as_me:$LINENO: checking for $ac_word" >&5
10842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10843 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10844   echo $ECHO_N "(cached) $ECHO_C" >&6
10845 else
10846   if test -n "$STRIP_FOR_TARGET"; then
10847   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10848 else
10849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10850 for as_dir in $PATH
10851 do
10852   IFS=$as_save_IFS
10853   test -z "$as_dir" && as_dir=.
10854   for ac_exec_ext in '' $ac_executable_extensions; do
10855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10856     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10858     break 2
10859   fi
10860 done
10861 done
10862
10863 fi
10864 fi
10865 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10866 if test -n "$STRIP_FOR_TARGET"; then
10867   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10868 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10869 else
10870   echo "$as_me:$LINENO: result: no" >&5
10871 echo "${ECHO_T}no" >&6
10872 fi
10873
10874     fi
10875     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10876       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10877 set dummy ${ncn_progname}; ac_word=$2
10878 echo "$as_me:$LINENO: checking for $ac_word" >&5
10879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10880 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10881   echo $ECHO_N "(cached) $ECHO_C" >&6
10882 else
10883   if test -n "$STRIP_FOR_TARGET"; then
10884   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10885 else
10886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10887 for as_dir in $PATH
10888 do
10889   IFS=$as_save_IFS
10890   test -z "$as_dir" && as_dir=.
10891   for ac_exec_ext in '' $ac_executable_extensions; do
10892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10893     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10895     break 2
10896   fi
10897 done
10898 done
10899
10900 fi
10901 fi
10902 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10903 if test -n "$STRIP_FOR_TARGET"; then
10904   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10905 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10906 else
10907   echo "$as_me:$LINENO: result: no" >&5
10908 echo "${ECHO_T}no" >&6
10909 fi
10910
10911     fi
10912     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10913   done
10914 fi
10915
10916 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10917   set dummy strip
10918   if test $build = $target ; then
10919     STRIP_FOR_TARGET="$2"
10920   else
10921     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10922   fi
10923 else
10924   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10925 fi
10926
10927 else
10928   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10929 fi
10930
10931
10932
10933
10934 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10935   if test -n "$with_build_time_tools"; then
10936     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10937 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10938     if test -x $with_build_time_tools/windres; then
10939       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10940       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10941       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10942 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10943     else
10944       echo "$as_me:$LINENO: result: no" >&5
10945 echo "${ECHO_T}no" >&6
10946     fi
10947   elif test $build != $host && test $have_gcc_for_target = yes; then
10948     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10949     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10950     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10951   fi
10952 fi
10953 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10954   # Extract the first word of "windres", so it can be a program name with args.
10955 set dummy windres; ac_word=$2
10956 echo "$as_me:$LINENO: checking for $ac_word" >&5
10957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10958 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10959   echo $ECHO_N "(cached) $ECHO_C" >&6
10960 else
10961   case $WINDRES_FOR_TARGET in
10962   [\\/]* | ?:[\\/]*)
10963   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10964   ;;
10965   *)
10966   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10967 for as_dir in $gcc_cv_tool_dirs
10968 do
10969   IFS=$as_save_IFS
10970   test -z "$as_dir" && as_dir=.
10971   for ac_exec_ext in '' $ac_executable_extensions; do
10972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10973     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10975     break 2
10976   fi
10977 done
10978 done
10979
10980   ;;
10981 esac
10982 fi
10983 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10984
10985 if test -n "$WINDRES_FOR_TARGET"; then
10986   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10987 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10988 else
10989   echo "$as_me:$LINENO: result: no" >&5
10990 echo "${ECHO_T}no" >&6
10991 fi
10992
10993 fi
10994 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10995
10996
10997 if test -n "$WINDRES_FOR_TARGET"; then
10998   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10999 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11000   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11001 fi
11002
11003 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11004   for ncn_progname in windres; do
11005     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11006 set dummy ${ncn_progname}; ac_word=$2
11007 echo "$as_me:$LINENO: checking for $ac_word" >&5
11008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11009 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11010   echo $ECHO_N "(cached) $ECHO_C" >&6
11011 else
11012   if test -n "$WINDRES_FOR_TARGET"; then
11013   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11014 else
11015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11016 for as_dir in $PATH
11017 do
11018   IFS=$as_save_IFS
11019   test -z "$as_dir" && as_dir=.
11020   for ac_exec_ext in '' $ac_executable_extensions; do
11021   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11022     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11023     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11024     break 2
11025   fi
11026 done
11027 done
11028
11029 fi
11030 fi
11031 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11032 if test -n "$WINDRES_FOR_TARGET"; then
11033   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11034 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11035 else
11036   echo "$as_me:$LINENO: result: no" >&5
11037 echo "${ECHO_T}no" >&6
11038 fi
11039
11040   done
11041 fi
11042
11043 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11044   for ncn_progname in windres; do
11045     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11046 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11047     if test -x $with_build_time_tools/${ncn_progname}; then
11048       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11049       echo "$as_me:$LINENO: result: yes" >&5
11050 echo "${ECHO_T}yes" >&6
11051       break
11052     else
11053       echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055     fi
11056   done
11057 fi
11058
11059 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11060   for ncn_progname in windres; do
11061     if test -n "$ncn_target_tool_prefix"; then
11062       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11063 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11064 echo "$as_me:$LINENO: checking for $ac_word" >&5
11065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11066 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11067   echo $ECHO_N "(cached) $ECHO_C" >&6
11068 else
11069   if test -n "$WINDRES_FOR_TARGET"; then
11070   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11071 else
11072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11073 for as_dir in $PATH
11074 do
11075   IFS=$as_save_IFS
11076   test -z "$as_dir" && as_dir=.
11077   for ac_exec_ext in '' $ac_executable_extensions; do
11078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11079     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11081     break 2
11082   fi
11083 done
11084 done
11085
11086 fi
11087 fi
11088 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11089 if test -n "$WINDRES_FOR_TARGET"; then
11090   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11091 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11092 else
11093   echo "$as_me:$LINENO: result: no" >&5
11094 echo "${ECHO_T}no" >&6
11095 fi
11096
11097     fi
11098     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11099       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11100 set dummy ${ncn_progname}; ac_word=$2
11101 echo "$as_me:$LINENO: checking for $ac_word" >&5
11102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11103 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11104   echo $ECHO_N "(cached) $ECHO_C" >&6
11105 else
11106   if test -n "$WINDRES_FOR_TARGET"; then
11107   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11108 else
11109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11110 for as_dir in $PATH
11111 do
11112   IFS=$as_save_IFS
11113   test -z "$as_dir" && as_dir=.
11114   for ac_exec_ext in '' $ac_executable_extensions; do
11115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11116     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11118     break 2
11119   fi
11120 done
11121 done
11122
11123 fi
11124 fi
11125 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11126 if test -n "$WINDRES_FOR_TARGET"; then
11127   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11128 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11129 else
11130   echo "$as_me:$LINENO: result: no" >&5
11131 echo "${ECHO_T}no" >&6
11132 fi
11133
11134     fi
11135     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11136   done
11137 fi
11138
11139 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11140   set dummy windres
11141   if test $build = $target ; then
11142     WINDRES_FOR_TARGET="$2"
11143   else
11144     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11145   fi
11146 else
11147   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11148 fi
11149
11150 else
11151   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11152 fi
11153
11154
11155
11156
11157 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11158   if test -n "$with_build_time_tools"; then
11159     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11160 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11161     if test -x $with_build_time_tools/windmc; then
11162       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11163       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11164       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11165 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11166     else
11167       echo "$as_me:$LINENO: result: no" >&5
11168 echo "${ECHO_T}no" >&6
11169     fi
11170   elif test $build != $host && test $have_gcc_for_target = yes; then
11171     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11172     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11173     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11174   fi
11175 fi
11176 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11177   # Extract the first word of "windmc", so it can be a program name with args.
11178 set dummy windmc; ac_word=$2
11179 echo "$as_me:$LINENO: checking for $ac_word" >&5
11180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11181 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11182   echo $ECHO_N "(cached) $ECHO_C" >&6
11183 else
11184   case $WINDMC_FOR_TARGET in
11185   [\\/]* | ?:[\\/]*)
11186   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11187   ;;
11188   *)
11189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11190 for as_dir in $gcc_cv_tool_dirs
11191 do
11192   IFS=$as_save_IFS
11193   test -z "$as_dir" && as_dir=.
11194   for ac_exec_ext in '' $ac_executable_extensions; do
11195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11196     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11198     break 2
11199   fi
11200 done
11201 done
11202
11203   ;;
11204 esac
11205 fi
11206 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11207
11208 if test -n "$WINDMC_FOR_TARGET"; then
11209   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11210 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11211 else
11212   echo "$as_me:$LINENO: result: no" >&5
11213 echo "${ECHO_T}no" >&6
11214 fi
11215
11216 fi
11217 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11218
11219
11220 if test -n "$WINDMC_FOR_TARGET"; then
11221   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11222 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11223   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11224 fi
11225
11226 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11227   for ncn_progname in windmc; do
11228     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11229 set dummy ${ncn_progname}; ac_word=$2
11230 echo "$as_me:$LINENO: checking for $ac_word" >&5
11231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11232 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11233   echo $ECHO_N "(cached) $ECHO_C" >&6
11234 else
11235   if test -n "$WINDMC_FOR_TARGET"; then
11236   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11237 else
11238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11239 for as_dir in $PATH
11240 do
11241   IFS=$as_save_IFS
11242   test -z "$as_dir" && as_dir=.
11243   for ac_exec_ext in '' $ac_executable_extensions; do
11244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11245     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11247     break 2
11248   fi
11249 done
11250 done
11251
11252 fi
11253 fi
11254 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11255 if test -n "$WINDMC_FOR_TARGET"; then
11256   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11257 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11258 else
11259   echo "$as_me:$LINENO: result: no" >&5
11260 echo "${ECHO_T}no" >&6
11261 fi
11262
11263   done
11264 fi
11265
11266 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11267   for ncn_progname in windmc; do
11268     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11269 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11270     if test -x $with_build_time_tools/${ncn_progname}; then
11271       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11272       echo "$as_me:$LINENO: result: yes" >&5
11273 echo "${ECHO_T}yes" >&6
11274       break
11275     else
11276       echo "$as_me:$LINENO: result: no" >&5
11277 echo "${ECHO_T}no" >&6
11278     fi
11279   done
11280 fi
11281
11282 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11283   for ncn_progname in windmc; do
11284     if test -n "$ncn_target_tool_prefix"; then
11285       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11286 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11287 echo "$as_me:$LINENO: checking for $ac_word" >&5
11288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11289 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11290   echo $ECHO_N "(cached) $ECHO_C" >&6
11291 else
11292   if test -n "$WINDMC_FOR_TARGET"; then
11293   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11294 else
11295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11296 for as_dir in $PATH
11297 do
11298   IFS=$as_save_IFS
11299   test -z "$as_dir" && as_dir=.
11300   for ac_exec_ext in '' $ac_executable_extensions; do
11301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11302     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11304     break 2
11305   fi
11306 done
11307 done
11308
11309 fi
11310 fi
11311 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11312 if test -n "$WINDMC_FOR_TARGET"; then
11313   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11314 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11315 else
11316   echo "$as_me:$LINENO: result: no" >&5
11317 echo "${ECHO_T}no" >&6
11318 fi
11319
11320     fi
11321     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11322       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11323 set dummy ${ncn_progname}; ac_word=$2
11324 echo "$as_me:$LINENO: checking for $ac_word" >&5
11325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11326 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11327   echo $ECHO_N "(cached) $ECHO_C" >&6
11328 else
11329   if test -n "$WINDMC_FOR_TARGET"; then
11330   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11331 else
11332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11333 for as_dir in $PATH
11334 do
11335   IFS=$as_save_IFS
11336   test -z "$as_dir" && as_dir=.
11337   for ac_exec_ext in '' $ac_executable_extensions; do
11338   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11339     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11340     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11341     break 2
11342   fi
11343 done
11344 done
11345
11346 fi
11347 fi
11348 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11349 if test -n "$WINDMC_FOR_TARGET"; then
11350   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11351 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11352 else
11353   echo "$as_me:$LINENO: result: no" >&5
11354 echo "${ECHO_T}no" >&6
11355 fi
11356
11357     fi
11358     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11359   done
11360 fi
11361
11362 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11363   set dummy windmc
11364   if test $build = $target ; then
11365     WINDMC_FOR_TARGET="$2"
11366   else
11367     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11368   fi
11369 else
11370   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11371 fi
11372
11373 else
11374   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11375 fi
11376
11377
11378 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11379
11380 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11381 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11382 if test "x${build}" != "x${host}" ; then
11383   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11384     # We already found the complete path
11385     ac_dir=`dirname $AR_FOR_TARGET`
11386     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11387 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11388   else
11389     # Canadian cross, just use what we found
11390     echo "$as_me:$LINENO: result: pre-installed" >&5
11391 echo "${ECHO_T}pre-installed" >&6
11392   fi
11393 else
11394   ok=yes
11395   case " ${configdirs} " in
11396     *" binutils "*) ;;
11397     *) ok=no ;;
11398   esac
11399
11400   if test $ok = yes; then
11401     # An in-tree tool is available and we can use it
11402     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11403     echo "$as_me:$LINENO: result: just compiled" >&5
11404 echo "${ECHO_T}just compiled" >&6
11405   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11406     # We already found the complete path
11407     ac_dir=`dirname $AR_FOR_TARGET`
11408     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11409 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11410   elif test "x$target" = "x$host"; then
11411     # We can use an host tool
11412     AR_FOR_TARGET='$(AR)'
11413     echo "$as_me:$LINENO: result: host tool" >&5
11414 echo "${ECHO_T}host tool" >&6
11415   else
11416     # We need a cross tool
11417     echo "$as_me:$LINENO: result: pre-installed" >&5
11418 echo "${ECHO_T}pre-installed" >&6
11419   fi
11420 fi
11421
11422 echo "$as_me:$LINENO: checking where to find the target as" >&5
11423 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11424 if test "x${build}" != "x${host}" ; then
11425   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11426     # We already found the complete path
11427     ac_dir=`dirname $AS_FOR_TARGET`
11428     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11429 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11430   else
11431     # Canadian cross, just use what we found
11432     echo "$as_me:$LINENO: result: pre-installed" >&5
11433 echo "${ECHO_T}pre-installed" >&6
11434   fi
11435 else
11436   ok=yes
11437   case " ${configdirs} " in
11438     *" gas "*) ;;
11439     *) ok=no ;;
11440   esac
11441
11442   if test $ok = yes; then
11443     # An in-tree tool is available and we can use it
11444     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11445     echo "$as_me:$LINENO: result: just compiled" >&5
11446 echo "${ECHO_T}just compiled" >&6
11447   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11448     # We already found the complete path
11449     ac_dir=`dirname $AS_FOR_TARGET`
11450     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11451 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11452   elif test "x$target" = "x$host"; then
11453     # We can use an host tool
11454     AS_FOR_TARGET='$(AS)'
11455     echo "$as_me:$LINENO: result: host tool" >&5
11456 echo "${ECHO_T}host tool" >&6
11457   else
11458     # We need a cross tool
11459     echo "$as_me:$LINENO: result: pre-installed" >&5
11460 echo "${ECHO_T}pre-installed" >&6
11461   fi
11462 fi
11463
11464 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11465 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11466 if test "x${build}" != "x${host}" ; then
11467   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11468     # We already found the complete path
11469     ac_dir=`dirname $CC_FOR_TARGET`
11470     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11471 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11472   else
11473     # Canadian cross, just use what we found
11474     echo "$as_me:$LINENO: result: pre-installed" >&5
11475 echo "${ECHO_T}pre-installed" >&6
11476   fi
11477 else
11478   ok=yes
11479   case " ${configdirs} " in
11480     *" gcc "*) ;;
11481     *) ok=no ;;
11482   esac
11483
11484   if test $ok = yes; then
11485     # An in-tree tool is available and we can use it
11486     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11487     echo "$as_me:$LINENO: result: just compiled" >&5
11488 echo "${ECHO_T}just compiled" >&6
11489   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11490     # We already found the complete path
11491     ac_dir=`dirname $CC_FOR_TARGET`
11492     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11493 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11494   elif test "x$target" = "x$host"; then
11495     # We can use an host tool
11496     CC_FOR_TARGET='$(CC)'
11497     echo "$as_me:$LINENO: result: host tool" >&5
11498 echo "${ECHO_T}host tool" >&6
11499   else
11500     # We need a cross tool
11501     echo "$as_me:$LINENO: result: pre-installed" >&5
11502 echo "${ECHO_T}pre-installed" >&6
11503   fi
11504 fi
11505
11506 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11507 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11508 if test "x${build}" != "x${host}" ; then
11509   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11510     # We already found the complete path
11511     ac_dir=`dirname $CXX_FOR_TARGET`
11512     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11513 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11514   else
11515     # Canadian cross, just use what we found
11516     echo "$as_me:$LINENO: result: pre-installed" >&5
11517 echo "${ECHO_T}pre-installed" >&6
11518   fi
11519 else
11520   ok=yes
11521   case " ${configdirs} " in
11522     *" gcc "*) ;;
11523     *) ok=no ;;
11524   esac
11525   case ,${enable_languages}, in
11526     *,c++,*) ;;
11527     *) ok=no ;;
11528   esac
11529   if test $ok = yes; then
11530     # An in-tree tool is available and we can use it
11531     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'
11532     echo "$as_me:$LINENO: result: just compiled" >&5
11533 echo "${ECHO_T}just compiled" >&6
11534   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11535     # We already found the complete path
11536     ac_dir=`dirname $CXX_FOR_TARGET`
11537     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11538 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11539   elif test "x$target" = "x$host"; then
11540     # We can use an host tool
11541     CXX_FOR_TARGET='$(CXX)'
11542     echo "$as_me:$LINENO: result: host tool" >&5
11543 echo "${ECHO_T}host tool" >&6
11544   else
11545     # We need a cross tool
11546     echo "$as_me:$LINENO: result: pre-installed" >&5
11547 echo "${ECHO_T}pre-installed" >&6
11548   fi
11549 fi
11550
11551 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11552 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11553 if test "x${build}" != "x${host}" ; then
11554   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11555     # We already found the complete path
11556     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11557     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11558 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11559   else
11560     # Canadian cross, just use what we found
11561     echo "$as_me:$LINENO: result: pre-installed" >&5
11562 echo "${ECHO_T}pre-installed" >&6
11563   fi
11564 else
11565   ok=yes
11566   case " ${configdirs} " in
11567     *" gcc "*) ;;
11568     *) ok=no ;;
11569   esac
11570   case ,${enable_languages}, in
11571     *,c++,*) ;;
11572     *) ok=no ;;
11573   esac
11574   if test $ok = yes; then
11575     # An in-tree tool is available and we can use it
11576     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'
11577     echo "$as_me:$LINENO: result: just compiled" >&5
11578 echo "${ECHO_T}just compiled" >&6
11579   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11580     # We already found the complete path
11581     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11582     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11583 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11584   elif test "x$target" = "x$host"; then
11585     # We can use an host tool
11586     RAW_CXX_FOR_TARGET='$(CXX)'
11587     echo "$as_me:$LINENO: result: host tool" >&5
11588 echo "${ECHO_T}host tool" >&6
11589   else
11590     # We need a cross tool
11591     echo "$as_me:$LINENO: result: pre-installed" >&5
11592 echo "${ECHO_T}pre-installed" >&6
11593   fi
11594 fi
11595
11596 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11597 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11598 if test "x${build}" != "x${host}" ; then
11599   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11600     # We already found the complete path
11601     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11602     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11603 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11604   else
11605     # Canadian cross, just use what we found
11606     echo "$as_me:$LINENO: result: pre-installed" >&5
11607 echo "${ECHO_T}pre-installed" >&6
11608   fi
11609 else
11610   ok=yes
11611   case " ${configdirs} " in
11612     *" binutils "*) ;;
11613     *) ok=no ;;
11614   esac
11615
11616   if test $ok = yes; then
11617     # An in-tree tool is available and we can use it
11618     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11619     echo "$as_me:$LINENO: result: just compiled" >&5
11620 echo "${ECHO_T}just compiled" >&6
11621   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11622     # We already found the complete path
11623     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11624     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11625 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11626   elif test "x$target" = "x$host"; then
11627     # We can use an host tool
11628     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11629     echo "$as_me:$LINENO: result: host tool" >&5
11630 echo "${ECHO_T}host tool" >&6
11631   else
11632     # We need a cross tool
11633     echo "$as_me:$LINENO: result: pre-installed" >&5
11634 echo "${ECHO_T}pre-installed" >&6
11635   fi
11636 fi
11637
11638 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11639 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11640 if test "x${build}" != "x${host}" ; then
11641   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11642     # We already found the complete path
11643     ac_dir=`dirname $GCC_FOR_TARGET`
11644     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11645 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11646   else
11647     # Canadian cross, just use what we found
11648     echo "$as_me:$LINENO: result: pre-installed" >&5
11649 echo "${ECHO_T}pre-installed" >&6
11650   fi
11651 else
11652   ok=yes
11653   case " ${configdirs} " in
11654     *" gcc "*) ;;
11655     *) ok=no ;;
11656   esac
11657
11658   if test $ok = yes; then
11659     # An in-tree tool is available and we can use it
11660     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11661     echo "$as_me:$LINENO: result: just compiled" >&5
11662 echo "${ECHO_T}just compiled" >&6
11663   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11664     # We already found the complete path
11665     ac_dir=`dirname $GCC_FOR_TARGET`
11666     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11667 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11668   elif test "x$target" = "x$host"; then
11669     # We can use an host tool
11670     GCC_FOR_TARGET='$()'
11671     echo "$as_me:$LINENO: result: host tool" >&5
11672 echo "${ECHO_T}host tool" >&6
11673   else
11674     # We need a cross tool
11675     echo "$as_me:$LINENO: result: pre-installed" >&5
11676 echo "${ECHO_T}pre-installed" >&6
11677   fi
11678 fi
11679
11680 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11681 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11682 if test "x${build}" != "x${host}" ; then
11683   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11684     # We already found the complete path
11685     ac_dir=`dirname $GCJ_FOR_TARGET`
11686     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11687 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11688   else
11689     # Canadian cross, just use what we found
11690     echo "$as_me:$LINENO: result: pre-installed" >&5
11691 echo "${ECHO_T}pre-installed" >&6
11692   fi
11693 else
11694   ok=yes
11695   case " ${configdirs} " in
11696     *" gcc "*) ;;
11697     *) ok=no ;;
11698   esac
11699   case ,${enable_languages}, in
11700     *,java,*) ;;
11701     *) ok=no ;;
11702   esac
11703   if test $ok = yes; then
11704     # An in-tree tool is available and we can use it
11705     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11706     echo "$as_me:$LINENO: result: just compiled" >&5
11707 echo "${ECHO_T}just compiled" >&6
11708   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11709     # We already found the complete path
11710     ac_dir=`dirname $GCJ_FOR_TARGET`
11711     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11712 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11713   elif test "x$target" = "x$host"; then
11714     # We can use an host tool
11715     GCJ_FOR_TARGET='$(GCJ)'
11716     echo "$as_me:$LINENO: result: host tool" >&5
11717 echo "${ECHO_T}host tool" >&6
11718   else
11719     # We need a cross tool
11720     echo "$as_me:$LINENO: result: pre-installed" >&5
11721 echo "${ECHO_T}pre-installed" >&6
11722   fi
11723 fi
11724
11725 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11726 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11727 if test "x${build}" != "x${host}" ; then
11728   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11729     # We already found the complete path
11730     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11731     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11732 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11733   else
11734     # Canadian cross, just use what we found
11735     echo "$as_me:$LINENO: result: pre-installed" >&5
11736 echo "${ECHO_T}pre-installed" >&6
11737   fi
11738 else
11739   ok=yes
11740   case " ${configdirs} " in
11741     *" gcc "*) ;;
11742     *) ok=no ;;
11743   esac
11744   case ,${enable_languages}, in
11745     *,fortran,*) ;;
11746     *) ok=no ;;
11747   esac
11748   if test $ok = yes; then
11749     # An in-tree tool is available and we can use it
11750     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11751     echo "$as_me:$LINENO: result: just compiled" >&5
11752 echo "${ECHO_T}just compiled" >&6
11753   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11754     # We already found the complete path
11755     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11756     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11757 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11758   elif test "x$target" = "x$host"; then
11759     # We can use an host tool
11760     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11761     echo "$as_me:$LINENO: result: host tool" >&5
11762 echo "${ECHO_T}host tool" >&6
11763   else
11764     # We need a cross tool
11765     echo "$as_me:$LINENO: result: pre-installed" >&5
11766 echo "${ECHO_T}pre-installed" >&6
11767   fi
11768 fi
11769
11770 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11771 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11772 if test "x${build}" != "x${host}" ; then
11773   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11774     # We already found the complete path
11775     ac_dir=`dirname $LD_FOR_TARGET`
11776     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11777 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11778   else
11779     # Canadian cross, just use what we found
11780     echo "$as_me:$LINENO: result: pre-installed" >&5
11781 echo "${ECHO_T}pre-installed" >&6
11782   fi
11783 else
11784   ok=yes
11785   case " ${configdirs} " in
11786     *" ld "*) ;;
11787     *) ok=no ;;
11788   esac
11789
11790   if test $ok = yes; then
11791     # An in-tree tool is available and we can use it
11792     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11793     echo "$as_me:$LINENO: result: just compiled" >&5
11794 echo "${ECHO_T}just compiled" >&6
11795   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11796     # We already found the complete path
11797     ac_dir=`dirname $LD_FOR_TARGET`
11798     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11799 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11800   elif test "x$target" = "x$host"; then
11801     # We can use an host tool
11802     LD_FOR_TARGET='$(LD)'
11803     echo "$as_me:$LINENO: result: host tool" >&5
11804 echo "${ECHO_T}host tool" >&6
11805   else
11806     # We need a cross tool
11807     echo "$as_me:$LINENO: result: pre-installed" >&5
11808 echo "${ECHO_T}pre-installed" >&6
11809   fi
11810 fi
11811
11812 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11813 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11814 if test "x${build}" != "x${host}" ; then
11815   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11816     # We already found the complete path
11817     ac_dir=`dirname $LIPO_FOR_TARGET`
11818     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11819 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11820   else
11821     # Canadian cross, just use what we found
11822     echo "$as_me:$LINENO: result: pre-installed" >&5
11823 echo "${ECHO_T}pre-installed" >&6
11824   fi
11825 else
11826   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11827     # We already found the complete path
11828     ac_dir=`dirname $LIPO_FOR_TARGET`
11829     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11830 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11831   elif test "x$target" = "x$host"; then
11832     # We can use an host tool
11833     LIPO_FOR_TARGET='$(LIPO)'
11834     echo "$as_me:$LINENO: result: host tool" >&5
11835 echo "${ECHO_T}host tool" >&6
11836   else
11837     # We need a cross tool
11838     echo "$as_me:$LINENO: result: pre-installed" >&5
11839 echo "${ECHO_T}pre-installed" >&6
11840   fi
11841 fi
11842
11843 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11844 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11845 if test "x${build}" != "x${host}" ; then
11846   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11847     # We already found the complete path
11848     ac_dir=`dirname $NM_FOR_TARGET`
11849     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11850 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11851   else
11852     # Canadian cross, just use what we found
11853     echo "$as_me:$LINENO: result: pre-installed" >&5
11854 echo "${ECHO_T}pre-installed" >&6
11855   fi
11856 else
11857   ok=yes
11858   case " ${configdirs} " in
11859     *" binutils "*) ;;
11860     *) ok=no ;;
11861   esac
11862
11863   if test $ok = yes; then
11864     # An in-tree tool is available and we can use it
11865     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11866     echo "$as_me:$LINENO: result: just compiled" >&5
11867 echo "${ECHO_T}just compiled" >&6
11868   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11869     # We already found the complete path
11870     ac_dir=`dirname $NM_FOR_TARGET`
11871     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11872 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11873   elif test "x$target" = "x$host"; then
11874     # We can use an host tool
11875     NM_FOR_TARGET='$(NM)'
11876     echo "$as_me:$LINENO: result: host tool" >&5
11877 echo "${ECHO_T}host tool" >&6
11878   else
11879     # We need a cross tool
11880     echo "$as_me:$LINENO: result: pre-installed" >&5
11881 echo "${ECHO_T}pre-installed" >&6
11882   fi
11883 fi
11884
11885 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11886 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11887 if test "x${build}" != "x${host}" ; then
11888   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11889     # We already found the complete path
11890     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11891     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11892 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11893   else
11894     # Canadian cross, just use what we found
11895     echo "$as_me:$LINENO: result: pre-installed" >&5
11896 echo "${ECHO_T}pre-installed" >&6
11897   fi
11898 else
11899   ok=yes
11900   case " ${configdirs} " in
11901     *" binutils "*) ;;
11902     *) ok=no ;;
11903   esac
11904
11905   if test $ok = yes; then
11906     # An in-tree tool is available and we can use it
11907     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11908     echo "$as_me:$LINENO: result: just compiled" >&5
11909 echo "${ECHO_T}just compiled" >&6
11910   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11911     # We already found the complete path
11912     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11913     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11914 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11915   elif test "x$target" = "x$host"; then
11916     # We can use an host tool
11917     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11918     echo "$as_me:$LINENO: result: host tool" >&5
11919 echo "${ECHO_T}host tool" >&6
11920   else
11921     # We need a cross tool
11922     echo "$as_me:$LINENO: result: pre-installed" >&5
11923 echo "${ECHO_T}pre-installed" >&6
11924   fi
11925 fi
11926
11927 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11928 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11929 if test "x${build}" != "x${host}" ; then
11930   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11931     # We already found the complete path
11932     ac_dir=`dirname $RANLIB_FOR_TARGET`
11933     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11934 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11935   else
11936     # Canadian cross, just use what we found
11937     echo "$as_me:$LINENO: result: pre-installed" >&5
11938 echo "${ECHO_T}pre-installed" >&6
11939   fi
11940 else
11941   ok=yes
11942   case " ${configdirs} " in
11943     *" binutils "*) ;;
11944     *) ok=no ;;
11945   esac
11946
11947   if test $ok = yes; then
11948     # An in-tree tool is available and we can use it
11949     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11950     echo "$as_me:$LINENO: result: just compiled" >&5
11951 echo "${ECHO_T}just compiled" >&6
11952   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11953     # We already found the complete path
11954     ac_dir=`dirname $RANLIB_FOR_TARGET`
11955     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11956 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11957   elif test "x$target" = "x$host"; then
11958     # We can use an host tool
11959     RANLIB_FOR_TARGET='$(RANLIB)'
11960     echo "$as_me:$LINENO: result: host tool" >&5
11961 echo "${ECHO_T}host tool" >&6
11962   else
11963     # We need a cross tool
11964     echo "$as_me:$LINENO: result: pre-installed" >&5
11965 echo "${ECHO_T}pre-installed" >&6
11966   fi
11967 fi
11968
11969 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11970 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11971 if test "x${build}" != "x${host}" ; then
11972   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11973     # We already found the complete path
11974     ac_dir=`dirname $STRIP_FOR_TARGET`
11975     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11976 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11977   else
11978     # Canadian cross, just use what we found
11979     echo "$as_me:$LINENO: result: pre-installed" >&5
11980 echo "${ECHO_T}pre-installed" >&6
11981   fi
11982 else
11983   ok=yes
11984   case " ${configdirs} " in
11985     *" binutils "*) ;;
11986     *) ok=no ;;
11987   esac
11988
11989   if test $ok = yes; then
11990     # An in-tree tool is available and we can use it
11991     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11992     echo "$as_me:$LINENO: result: just compiled" >&5
11993 echo "${ECHO_T}just compiled" >&6
11994   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11995     # We already found the complete path
11996     ac_dir=`dirname $STRIP_FOR_TARGET`
11997     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11998 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11999   elif test "x$target" = "x$host"; then
12000     # We can use an host tool
12001     STRIP_FOR_TARGET='$(STRIP)'
12002     echo "$as_me:$LINENO: result: host tool" >&5
12003 echo "${ECHO_T}host tool" >&6
12004   else
12005     # We need a cross tool
12006     echo "$as_me:$LINENO: result: pre-installed" >&5
12007 echo "${ECHO_T}pre-installed" >&6
12008   fi
12009 fi
12010
12011 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12012 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12013 if test "x${build}" != "x${host}" ; then
12014   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12015     # We already found the complete path
12016     ac_dir=`dirname $WINDRES_FOR_TARGET`
12017     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12018 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12019   else
12020     # Canadian cross, just use what we found
12021     echo "$as_me:$LINENO: result: pre-installed" >&5
12022 echo "${ECHO_T}pre-installed" >&6
12023   fi
12024 else
12025   ok=yes
12026   case " ${configdirs} " in
12027     *" binutils "*) ;;
12028     *) ok=no ;;
12029   esac
12030
12031   if test $ok = yes; then
12032     # An in-tree tool is available and we can use it
12033     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12034     echo "$as_me:$LINENO: result: just compiled" >&5
12035 echo "${ECHO_T}just compiled" >&6
12036   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12037     # We already found the complete path
12038     ac_dir=`dirname $WINDRES_FOR_TARGET`
12039     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12040 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12041   elif test "x$target" = "x$host"; then
12042     # We can use an host tool
12043     WINDRES_FOR_TARGET='$(WINDRES)'
12044     echo "$as_me:$LINENO: result: host tool" >&5
12045 echo "${ECHO_T}host tool" >&6
12046   else
12047     # We need a cross tool
12048     echo "$as_me:$LINENO: result: pre-installed" >&5
12049 echo "${ECHO_T}pre-installed" >&6
12050   fi
12051 fi
12052
12053 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12054 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12055 if test "x${build}" != "x${host}" ; then
12056   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12057     # We already found the complete path
12058     ac_dir=`dirname $WINDMC_FOR_TARGET`
12059     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12060 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12061   else
12062     # Canadian cross, just use what we found
12063     echo "$as_me:$LINENO: result: pre-installed" >&5
12064 echo "${ECHO_T}pre-installed" >&6
12065   fi
12066 else
12067   ok=yes
12068   case " ${configdirs} " in
12069     *" binutils "*) ;;
12070     *) ok=no ;;
12071   esac
12072
12073   if test $ok = yes; then
12074     # An in-tree tool is available and we can use it
12075     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12076     echo "$as_me:$LINENO: result: just compiled" >&5
12077 echo "${ECHO_T}just compiled" >&6
12078   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12079     # We already found the complete path
12080     ac_dir=`dirname $WINDMC_FOR_TARGET`
12081     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12082 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12083   elif test "x$target" = "x$host"; then
12084     # We can use an host tool
12085     WINDMC_FOR_TARGET='$(WINDMC)'
12086     echo "$as_me:$LINENO: result: host tool" >&5
12087 echo "${ECHO_T}host tool" >&6
12088   else
12089     # We need a cross tool
12090     echo "$as_me:$LINENO: result: pre-installed" >&5
12091 echo "${ECHO_T}pre-installed" >&6
12092   fi
12093 fi
12094
12095
12096
12097
12098
12099 # Certain tools may need extra flags.
12100 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12101 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12102 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12103
12104 # When building target libraries, except in a Canadian cross, we use
12105 # the same toolchain as the compiler we just built.
12106 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12107 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12108 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12109 if test $host = $build; then
12110   case " $configdirs " in
12111     *" gcc "*)
12112       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12113       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12114       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12115       ;;
12116   esac
12117 fi
12118
12119
12120
12121
12122
12123 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12124 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12125 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12126 if test "${enable_maintainer_mode+set}" = set; then
12127   enableval="$enable_maintainer_mode"
12128   USE_MAINTAINER_MODE=$enableval
12129 else
12130   USE_MAINTAINER_MODE=no
12131 fi;
12132 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12133 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12134
12135
12136 if test "$USE_MAINTAINER_MODE" = yes; then
12137   MAINTAINER_MODE_TRUE=
12138   MAINTAINER_MODE_FALSE='#'
12139 else
12140   MAINTAINER_MODE_TRUE='#'
12141   MAINTAINER_MODE_FALSE=
12142 fi
12143 MAINT=$MAINTAINER_MODE_TRUE
12144
12145 # ---------------------
12146 # GCC bootstrap support
12147 # ---------------------
12148
12149 # Stage specific cflags for build.
12150 stage1_cflags="-g"
12151 case $build in
12152   vax-*-*)
12153     case ${GCC} in
12154       yes) stage1_cflags="-g -Wa,-J" ;;
12155       *) stage1_cflags="-g -J" ;;
12156     esac ;;
12157 esac
12158
12159 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12160 if test "$GCC" = yes; then
12161   saved_CFLAGS="$CFLAGS"
12162
12163   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12164   CFLAGS="$CFLAGS -fkeep-inline-functions"
12165   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12166 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12167   cat >conftest.$ac_ext <<_ACEOF
12168 /* confdefs.h.  */
12169 _ACEOF
12170 cat confdefs.h >>conftest.$ac_ext
12171 cat >>conftest.$ac_ext <<_ACEOF
12172 /* end confdefs.h.  */
12173
12174 #if (__GNUC__ < 3) \
12175     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12176                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12177 #error http://gcc.gnu.org/PR29382
12178 #endif
12179
12180 int
12181 main ()
12182 {
12183
12184   ;
12185   return 0;
12186 }
12187 _ACEOF
12188 rm -f conftest.$ac_objext
12189 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12190   (eval $ac_compile) 2>conftest.er1
12191   ac_status=$?
12192   grep -v '^ *+' conftest.er1 >conftest.err
12193   rm -f conftest.er1
12194   cat conftest.err >&5
12195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12196   (exit $ac_status); } &&
12197          { ac_try='test -z "$ac_c_werror_flag"
12198                          || test ! -s conftest.err'
12199   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12200   (eval $ac_try) 2>&5
12201   ac_status=$?
12202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12203   (exit $ac_status); }; } &&
12204          { ac_try='test -s conftest.$ac_objext'
12205   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12206   (eval $ac_try) 2>&5
12207   ac_status=$?
12208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12209   (exit $ac_status); }; }; then
12210   echo "$as_me:$LINENO: result: yes" >&5
12211 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12212 else
12213   echo "$as_me: failed program was:" >&5
12214 sed 's/^/| /' conftest.$ac_ext >&5
12215
12216 echo "$as_me:$LINENO: result: no" >&5
12217 echo "${ECHO_T}no" >&6
12218 fi
12219 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12220
12221   CFLAGS="$saved_CFLAGS"
12222 fi
12223
12224
12225
12226 # Enable --enable-checking in stage1 of the compiler.
12227 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12228 if test "${enable_stage1_checking+set}" = set; then
12229   enableval="$enable_stage1_checking"
12230   stage1_checking=--enable-checking=${enable_stage1_checking}
12231 else
12232   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12233   stage1_checking=--enable-checking=yes,types
12234 else
12235   stage1_checking=--enable-checking=$enable_checking,types
12236 fi
12237 fi;
12238
12239
12240 # Enable -Werror in bootstrap stage2 and later.
12241 # Check whether --enable-werror or --disable-werror was given.
12242 if test "${enable_werror+set}" = set; then
12243   enableval="$enable_werror"
12244
12245 else
12246   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12247   enable_werror=yes
12248 else
12249   enable_werror=no
12250 fi
12251 fi;
12252 case ${enable_werror} in
12253   yes) stage2_werror_flag="--enable-werror-always" ;;
12254   *) stage2_werror_flag="" ;;
12255 esac
12256
12257
12258 # Flags needed to enable html installing and building
12259
12260 # Check whether --with-datarootdir or --without-datarootdir was given.
12261 if test "${with_datarootdir+set}" = set; then
12262   withval="$with_datarootdir"
12263   datarootdir="\${prefix}/${withval}"
12264 else
12265   datarootdir="\${prefix}/share"
12266 fi;
12267
12268
12269 # Check whether --with-docdir or --without-docdir was given.
12270 if test "${with_docdir+set}" = set; then
12271   withval="$with_docdir"
12272   docdir="\${prefix}/${withval}"
12273 else
12274   docdir="\${datarootdir}/doc"
12275 fi;
12276
12277
12278 # Check whether --with-pdfdir or --without-pdfdir was given.
12279 if test "${with_pdfdir+set}" = set; then
12280   withval="$with_pdfdir"
12281   pdfdir="\${prefix}/${withval}"
12282 else
12283   pdfdir="\${docdir}"
12284 fi;
12285
12286
12287 # Check whether --with-htmldir or --without-htmldir was given.
12288 if test "${with_htmldir+set}" = set; then
12289   withval="$with_htmldir"
12290   htmldir="\${prefix}/${withval}"
12291 else
12292   htmldir="\${docdir}"
12293 fi;
12294
12295
12296
12297
12298
12299
12300           ac_config_files="$ac_config_files Makefile"
12301 cat >confcache <<\_ACEOF
12302 # This file is a shell script that caches the results of configure
12303 # tests run on this system so they can be shared between configure
12304 # scripts and configure runs, see configure's option --config-cache.
12305 # It is not useful on other systems.  If it contains results you don't
12306 # want to keep, you may remove or edit it.
12307 #
12308 # config.status only pays attention to the cache file if you give it
12309 # the --recheck option to rerun configure.
12310 #
12311 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12312 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12313 # following values.
12314
12315 _ACEOF
12316
12317 # The following way of writing the cache mishandles newlines in values,
12318 # but we know of no workaround that is simple, portable, and efficient.
12319 # So, don't put newlines in cache variables' values.
12320 # Ultrix sh set writes to stderr and can't be redirected directly,
12321 # and sets the high bit in the cache file unless we assign to the vars.
12322 {
12323   (set) 2>&1 |
12324     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12325     *ac_space=\ *)
12326       # `set' does not quote correctly, so add quotes (double-quote
12327       # substitution turns \\\\ into \\, and sed turns \\ into \).
12328       sed -n \
12329         "s/'/'\\\\''/g;
12330           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12331       ;;
12332     *)
12333       # `set' quotes correctly as required by POSIX, so do not add quotes.
12334       sed -n \
12335         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12336       ;;
12337     esac;
12338 } |
12339   sed '
12340      t clear
12341      : clear
12342      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12343      t end
12344      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12345      : end' >>confcache
12346 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12347   if test -w $cache_file; then
12348     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12349     cat confcache >$cache_file
12350   else
12351     echo "not updating unwritable cache $cache_file"
12352   fi
12353 fi
12354 rm -f confcache
12355
12356 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12357 # Let make expand exec_prefix.
12358 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12359
12360 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12361 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12362 # trailing colons and then remove the whole line if VPATH becomes empty
12363 # (actually we leave an empty line to preserve line numbers).
12364 if test "x$srcdir" = x.; then
12365   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12366 s/:*\$(srcdir):*/:/;
12367 s/:*\${srcdir}:*/:/;
12368 s/:*@srcdir@:*/:/;
12369 s/^\([^=]*=[     ]*\):*/\1/;
12370 s/:*$//;
12371 s/^[^=]*=[       ]*$//;
12372 }'
12373 fi
12374
12375 # Transform confdefs.h into DEFS.
12376 # Protect against shell expansion while executing Makefile rules.
12377 # Protect against Makefile macro expansion.
12378 #
12379 # If the first sed substitution is executed (which looks for macros that
12380 # take arguments), then we branch to the quote section.  Otherwise,
12381 # look for a macro that doesn't take arguments.
12382 cat >confdef2opt.sed <<\_ACEOF
12383 t clear
12384 : clear
12385 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12386 t quote
12387 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12388 t quote
12389 d
12390 : quote
12391 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12392 s,\[,\\&,g
12393 s,\],\\&,g
12394 s,\$,$$,g
12395 p
12396 _ACEOF
12397 # We use echo to avoid assuming a particular line-breaking character.
12398 # The extra dot is to prevent the shell from consuming trailing
12399 # line-breaks from the sub-command output.  A line-break within
12400 # single-quotes doesn't work because, if this script is created in a
12401 # platform that uses two characters for line-breaks (e.g., DOS), tr
12402 # would break.
12403 ac_LF_and_DOT=`echo; echo .`
12404 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12405 rm -f confdef2opt.sed
12406
12407
12408 ac_libobjs=
12409 ac_ltlibobjs=
12410 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12411   # 1. Remove the extension, and $U if already installed.
12412   ac_i=`echo "$ac_i" |
12413          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12414   # 2. Add them.
12415   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12416   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12417 done
12418 LIBOBJS=$ac_libobjs
12419
12420 LTLIBOBJS=$ac_ltlibobjs
12421
12422
12423
12424 : ${CONFIG_STATUS=./config.status}
12425 ac_clean_files_save=$ac_clean_files
12426 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12427 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12428 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12429 cat >$CONFIG_STATUS <<_ACEOF
12430 #! $SHELL
12431 # Generated by $as_me.
12432 # Run this file to recreate the current configuration.
12433 # Compiler output produced by configure, useful for debugging
12434 # configure, is in config.log if it exists.
12435
12436 debug=false
12437 ac_cs_recheck=false
12438 ac_cs_silent=false
12439 SHELL=\${CONFIG_SHELL-$SHELL}
12440 _ACEOF
12441
12442 cat >>$CONFIG_STATUS <<\_ACEOF
12443 ## --------------------- ##
12444 ## M4sh Initialization.  ##
12445 ## --------------------- ##
12446
12447 # Be Bourne compatible
12448 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12449   emulate sh
12450   NULLCMD=:
12451   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12452   # is contrary to our usage.  Disable this feature.
12453   alias -g '${1+"$@"}'='"$@"'
12454 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12455   set -o posix
12456 fi
12457 DUALCASE=1; export DUALCASE # for MKS sh
12458
12459 # Support unset when possible.
12460 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12461   as_unset=unset
12462 else
12463   as_unset=false
12464 fi
12465
12466
12467 # Work around bugs in pre-3.0 UWIN ksh.
12468 $as_unset ENV MAIL MAILPATH
12469 PS1='$ '
12470 PS2='> '
12471 PS4='+ '
12472
12473 # NLS nuisances.
12474 for as_var in \
12475   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12476   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12477   LC_TELEPHONE LC_TIME
12478 do
12479   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12480     eval $as_var=C; export $as_var
12481   else
12482     $as_unset $as_var
12483   fi
12484 done
12485
12486 # Required to use basename.
12487 if expr a : '\(a\)' >/dev/null 2>&1; then
12488   as_expr=expr
12489 else
12490   as_expr=false
12491 fi
12492
12493 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12494   as_basename=basename
12495 else
12496   as_basename=false
12497 fi
12498
12499
12500 # Name of the executable.
12501 as_me=`$as_basename "$0" ||
12502 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12503          X"$0" : 'X\(//\)$' \| \
12504          X"$0" : 'X\(/\)$' \| \
12505          .     : '\(.\)' 2>/dev/null ||
12506 echo X/"$0" |
12507     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12508           /^X\/\(\/\/\)$/{ s//\1/; q; }
12509           /^X\/\(\/\).*/{ s//\1/; q; }
12510           s/.*/./; q'`
12511
12512
12513 # PATH needs CR, and LINENO needs CR and PATH.
12514 # Avoid depending upon Character Ranges.
12515 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12516 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12517 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12518 as_cr_digits='0123456789'
12519 as_cr_alnum=$as_cr_Letters$as_cr_digits
12520
12521 # The user is always right.
12522 if test "${PATH_SEPARATOR+set}" != set; then
12523   echo "#! /bin/sh" >conf$$.sh
12524   echo  "exit 0"   >>conf$$.sh
12525   chmod +x conf$$.sh
12526   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12527     PATH_SEPARATOR=';'
12528   else
12529     PATH_SEPARATOR=:
12530   fi
12531   rm -f conf$$.sh
12532 fi
12533
12534
12535   as_lineno_1=$LINENO
12536   as_lineno_2=$LINENO
12537   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12538   test "x$as_lineno_1" != "x$as_lineno_2" &&
12539   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12540   # Find who we are.  Look in the path if we contain no path at all
12541   # relative or not.
12542   case $0 in
12543     *[\\/]* ) as_myself=$0 ;;
12544     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12545 for as_dir in $PATH
12546 do
12547   IFS=$as_save_IFS
12548   test -z "$as_dir" && as_dir=.
12549   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12550 done
12551
12552        ;;
12553   esac
12554   # We did not find ourselves, most probably we were run as `sh COMMAND'
12555   # in which case we are not to be found in the path.
12556   if test "x$as_myself" = x; then
12557     as_myself=$0
12558   fi
12559   if test ! -f "$as_myself"; then
12560     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12561 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12562    { (exit 1); exit 1; }; }
12563   fi
12564   case $CONFIG_SHELL in
12565   '')
12566     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12567 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12568 do
12569   IFS=$as_save_IFS
12570   test -z "$as_dir" && as_dir=.
12571   for as_base in sh bash ksh sh5; do
12572          case $as_dir in
12573          /*)
12574            if ("$as_dir/$as_base" -c '
12575   as_lineno_1=$LINENO
12576   as_lineno_2=$LINENO
12577   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12578   test "x$as_lineno_1" != "x$as_lineno_2" &&
12579   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12580              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12581              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12582              CONFIG_SHELL=$as_dir/$as_base
12583              export CONFIG_SHELL
12584              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12585            fi;;
12586          esac
12587        done
12588 done
12589 ;;
12590   esac
12591
12592   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12593   # uniformly replaced by the line number.  The first 'sed' inserts a
12594   # line-number line before each line; the second 'sed' does the real
12595   # work.  The second script uses 'N' to pair each line-number line
12596   # with the numbered line, and appends trailing '-' during
12597   # substitution so that $LINENO is not a special case at line end.
12598   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12599   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12600   sed '=' <$as_myself |
12601     sed '
12602       N
12603       s,$,-,
12604       : loop
12605       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12606       t loop
12607       s,-$,,
12608       s,^['$as_cr_digits']*\n,,
12609     ' >$as_me.lineno &&
12610   chmod +x $as_me.lineno ||
12611     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12612 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12613    { (exit 1); exit 1; }; }
12614
12615   # Don't try to exec as it changes $[0], causing all sort of problems
12616   # (the dirname of $[0] is not the place where we might find the
12617   # original and so on.  Autoconf is especially sensible to this).
12618   . ./$as_me.lineno
12619   # Exit status is that of the last command.
12620   exit
12621 }
12622
12623
12624 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12625   *c*,-n*) ECHO_N= ECHO_C='
12626 ' ECHO_T='      ' ;;
12627   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12628   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12629 esac
12630
12631 if expr a : '\(a\)' >/dev/null 2>&1; then
12632   as_expr=expr
12633 else
12634   as_expr=false
12635 fi
12636
12637 rm -f conf$$ conf$$.exe conf$$.file
12638 echo >conf$$.file
12639 if ln -s conf$$.file conf$$ 2>/dev/null; then
12640   # We could just check for DJGPP; but this test a) works b) is more generic
12641   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12642   if test -f conf$$.exe; then
12643     # Don't use ln at all; we don't have any links
12644     as_ln_s='cp -p'
12645   else
12646     as_ln_s='ln -s'
12647   fi
12648 elif ln conf$$.file conf$$ 2>/dev/null; then
12649   as_ln_s=ln
12650 else
12651   as_ln_s='cp -p'
12652 fi
12653 rm -f conf$$ conf$$.exe conf$$.file
12654
12655 if mkdir -p . 2>/dev/null; then
12656   as_mkdir_p=:
12657 else
12658   test -d ./-p && rmdir ./-p
12659   as_mkdir_p=false
12660 fi
12661
12662 as_executable_p="test -f"
12663
12664 # Sed expression to map a string onto a valid CPP name.
12665 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12666
12667 # Sed expression to map a string onto a valid variable name.
12668 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12669
12670
12671 # IFS
12672 # We need space, tab and new line, in precisely that order.
12673 as_nl='
12674 '
12675 IFS="   $as_nl"
12676
12677 # CDPATH.
12678 $as_unset CDPATH
12679
12680 exec 6>&1
12681
12682 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12683 # report actual input values of CONFIG_FILES etc. instead of their
12684 # values after options handling.  Logging --version etc. is OK.
12685 exec 5>>config.log
12686 {
12687   echo
12688   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12689 ## Running $as_me. ##
12690 _ASBOX
12691 } >&5
12692 cat >&5 <<_CSEOF
12693
12694 This file was extended by $as_me, which was
12695 generated by GNU Autoconf 2.59.  Invocation command line was
12696
12697   CONFIG_FILES    = $CONFIG_FILES
12698   CONFIG_HEADERS  = $CONFIG_HEADERS
12699   CONFIG_LINKS    = $CONFIG_LINKS
12700   CONFIG_COMMANDS = $CONFIG_COMMANDS
12701   $ $0 $@
12702
12703 _CSEOF
12704 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12705 echo >&5
12706 _ACEOF
12707
12708 # Files that config.status was made for.
12709 if test -n "$ac_config_files"; then
12710   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12711 fi
12712
12713 if test -n "$ac_config_headers"; then
12714   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12715 fi
12716
12717 if test -n "$ac_config_links"; then
12718   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12719 fi
12720
12721 if test -n "$ac_config_commands"; then
12722   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12723 fi
12724
12725 cat >>$CONFIG_STATUS <<\_ACEOF
12726
12727 ac_cs_usage="\
12728 \`$as_me' instantiates files from templates according to the
12729 current configuration.
12730
12731 Usage: $0 [OPTIONS] [FILE]...
12732
12733   -h, --help       print this help, then exit
12734   -V, --version    print version number, then exit
12735   -q, --quiet      do not print progress messages
12736   -d, --debug      don't remove temporary files
12737       --recheck    update $as_me by reconfiguring in the same conditions
12738   --file=FILE[:TEMPLATE]
12739                    instantiate the configuration file FILE
12740
12741 Configuration files:
12742 $config_files
12743
12744 Report bugs to <bug-autoconf@gnu.org>."
12745 _ACEOF
12746
12747 cat >>$CONFIG_STATUS <<_ACEOF
12748 ac_cs_version="\\
12749 config.status
12750 configured by $0, generated by GNU Autoconf 2.59,
12751   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12752
12753 Copyright (C) 2003 Free Software Foundation, Inc.
12754 This config.status script is free software; the Free Software Foundation
12755 gives unlimited permission to copy, distribute and modify it."
12756 srcdir=$srcdir
12757 INSTALL="$INSTALL"
12758 _ACEOF
12759
12760 cat >>$CONFIG_STATUS <<\_ACEOF
12761 # If no file are specified by the user, then we need to provide default
12762 # value.  By we need to know if files were specified by the user.
12763 ac_need_defaults=:
12764 while test $# != 0
12765 do
12766   case $1 in
12767   --*=*)
12768     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12769     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12770     ac_shift=:
12771     ;;
12772   -*)
12773     ac_option=$1
12774     ac_optarg=$2
12775     ac_shift=shift
12776     ;;
12777   *) # This is not an option, so the user has probably given explicit
12778      # arguments.
12779      ac_option=$1
12780      ac_need_defaults=false;;
12781   esac
12782
12783   case $ac_option in
12784   # Handling of the options.
12785 _ACEOF
12786 cat >>$CONFIG_STATUS <<\_ACEOF
12787   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12788     ac_cs_recheck=: ;;
12789   --version | --vers* | -V )
12790     echo "$ac_cs_version"; exit 0 ;;
12791   --he | --h)
12792     # Conflict between --help and --header
12793     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12794 Try \`$0 --help' for more information." >&5
12795 echo "$as_me: error: ambiguous option: $1
12796 Try \`$0 --help' for more information." >&2;}
12797    { (exit 1); exit 1; }; };;
12798   --help | --hel | -h )
12799     echo "$ac_cs_usage"; exit 0 ;;
12800   --debug | --d* | -d )
12801     debug=: ;;
12802   --file | --fil | --fi | --f )
12803     $ac_shift
12804     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12805     ac_need_defaults=false;;
12806   --header | --heade | --head | --hea )
12807     $ac_shift
12808     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12809     ac_need_defaults=false;;
12810   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12811   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12812     ac_cs_silent=: ;;
12813
12814   # This is an error.
12815   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12816 Try \`$0 --help' for more information." >&5
12817 echo "$as_me: error: unrecognized option: $1
12818 Try \`$0 --help' for more information." >&2;}
12819    { (exit 1); exit 1; }; } ;;
12820
12821   *) ac_config_targets="$ac_config_targets $1" ;;
12822
12823   esac
12824   shift
12825 done
12826
12827 ac_configure_extra_args=
12828
12829 if $ac_cs_silent; then
12830   exec 6>/dev/null
12831   ac_configure_extra_args="$ac_configure_extra_args --silent"
12832 fi
12833
12834 _ACEOF
12835 cat >>$CONFIG_STATUS <<_ACEOF
12836 if \$ac_cs_recheck; then
12837   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12838   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12839 fi
12840
12841 _ACEOF
12842
12843
12844
12845
12846
12847 cat >>$CONFIG_STATUS <<\_ACEOF
12848 for ac_config_target in $ac_config_targets
12849 do
12850   case "$ac_config_target" in
12851   # Handling of arguments.
12852   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12853   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12854 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12855    { (exit 1); exit 1; }; };;
12856   esac
12857 done
12858
12859 # If the user did not use the arguments to specify the items to instantiate,
12860 # then the envvar interface is used.  Set only those that are not.
12861 # We use the long form for the default assignment because of an extremely
12862 # bizarre bug on SunOS 4.1.3.
12863 if $ac_need_defaults; then
12864   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12865 fi
12866
12867 # Have a temporary directory for convenience.  Make it in the build tree
12868 # simply because there is no reason to put it here, and in addition,
12869 # creating and moving files from /tmp can sometimes cause problems.
12870 # Create a temporary directory, and hook for its removal unless debugging.
12871 $debug ||
12872 {
12873   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12874   trap '{ (exit 1); exit 1; }' 1 2 13 15
12875 }
12876
12877 # Create a (secure) tmp directory for tmp files.
12878
12879 {
12880   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12881   test -n "$tmp" && test -d "$tmp"
12882 }  ||
12883 {
12884   tmp=./confstat$$-$RANDOM
12885   (umask 077 && mkdir $tmp)
12886 } ||
12887 {
12888    echo "$me: cannot create a temporary directory in ." >&2
12889    { (exit 1); exit 1; }
12890 }
12891
12892 _ACEOF
12893
12894 cat >>$CONFIG_STATUS <<_ACEOF
12895
12896 #
12897 # CONFIG_FILES section.
12898 #
12899
12900 # No need to generate the scripts if there are no CONFIG_FILES.
12901 # This happens for instance when ./config.status config.h
12902 if test -n "\$CONFIG_FILES"; then
12903   # Protect against being on the right side of a sed subst in config.status.
12904   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12905    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12906 s,@SHELL@,$SHELL,;t t
12907 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12908 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12909 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12910 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12911 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12912 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12913 s,@exec_prefix@,$exec_prefix,;t t
12914 s,@prefix@,$prefix,;t t
12915 s,@program_transform_name@,$program_transform_name,;t t
12916 s,@bindir@,$bindir,;t t
12917 s,@sbindir@,$sbindir,;t t
12918 s,@libexecdir@,$libexecdir,;t t
12919 s,@datadir@,$datadir,;t t
12920 s,@sysconfdir@,$sysconfdir,;t t
12921 s,@sharedstatedir@,$sharedstatedir,;t t
12922 s,@localstatedir@,$localstatedir,;t t
12923 s,@libdir@,$libdir,;t t
12924 s,@includedir@,$includedir,;t t
12925 s,@oldincludedir@,$oldincludedir,;t t
12926 s,@infodir@,$infodir,;t t
12927 s,@mandir@,$mandir,;t t
12928 s,@build_alias@,$build_alias,;t t
12929 s,@host_alias@,$host_alias,;t t
12930 s,@target_alias@,$target_alias,;t t
12931 s,@DEFS@,$DEFS,;t t
12932 s,@ECHO_C@,$ECHO_C,;t t
12933 s,@ECHO_N@,$ECHO_N,;t t
12934 s,@ECHO_T@,$ECHO_T,;t t
12935 s,@LIBS@,$LIBS,;t t
12936 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12937 s,@build@,$build,;t t
12938 s,@build_cpu@,$build_cpu,;t t
12939 s,@build_vendor@,$build_vendor,;t t
12940 s,@build_os@,$build_os,;t t
12941 s,@build_noncanonical@,$build_noncanonical,;t t
12942 s,@host_noncanonical@,$host_noncanonical,;t t
12943 s,@target_noncanonical@,$target_noncanonical,;t t
12944 s,@host@,$host,;t t
12945 s,@host_cpu@,$host_cpu,;t t
12946 s,@host_vendor@,$host_vendor,;t t
12947 s,@host_os@,$host_os,;t t
12948 s,@target@,$target,;t t
12949 s,@target_cpu@,$target_cpu,;t t
12950 s,@target_vendor@,$target_vendor,;t t
12951 s,@target_os@,$target_os,;t t
12952 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12953 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12954 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12955 s,@LN@,$LN,;t t
12956 s,@LN_S@,$LN_S,;t t
12957 s,@build_libsubdir@,$build_libsubdir,;t t
12958 s,@build_subdir@,$build_subdir,;t t
12959 s,@host_subdir@,$host_subdir,;t t
12960 s,@target_subdir@,$target_subdir,;t t
12961 s,@CC@,$CC,;t t
12962 s,@CFLAGS@,$CFLAGS,;t t
12963 s,@LDFLAGS@,$LDFLAGS,;t t
12964 s,@CPPFLAGS@,$CPPFLAGS,;t t
12965 s,@ac_ct_CC@,$ac_ct_CC,;t t
12966 s,@EXEEXT@,$EXEEXT,;t t
12967 s,@OBJEXT@,$OBJEXT,;t t
12968 s,@CXX@,$CXX,;t t
12969 s,@CXXFLAGS@,$CXXFLAGS,;t t
12970 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12971 s,@GNATBIND@,$GNATBIND,;t t
12972 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12973 s,@GNATMAKE@,$GNATMAKE,;t t
12974 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12975 s,@do_compare@,$do_compare,;t t
12976 s,@gmplibs@,$gmplibs,;t t
12977 s,@gmpinc@,$gmpinc,;t t
12978 s,@stage1_languages@,$stage1_languages,;t t
12979 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12980 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12981 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12982 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12983 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12984 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
12985 s,@tooldir@,$tooldir,;t t
12986 s,@build_tooldir@,$build_tooldir,;t t
12987 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12988 s,@GDB_TK@,$GDB_TK,;t t
12989 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12990 s,@build_configargs@,$build_configargs,;t t
12991 s,@build_configdirs@,$build_configdirs,;t t
12992 s,@host_configargs@,$host_configargs,;t t
12993 s,@configdirs@,$configdirs,;t t
12994 s,@target_configargs@,$target_configargs,;t t
12995 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12996 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12997 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12998 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12999 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13000 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13001 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13002 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13003 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13004 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13005 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13006 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13007 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13008 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13009 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13010 s,@config_shell@,$config_shell,;t t
13011 s,@YACC@,$YACC,;t t
13012 s,@BISON@,$BISON,;t t
13013 s,@M4@,$M4,;t t
13014 s,@LEX@,$LEX,;t t
13015 s,@FLEX@,$FLEX,;t t
13016 s,@MAKEINFO@,$MAKEINFO,;t t
13017 s,@EXPECT@,$EXPECT,;t t
13018 s,@RUNTEST@,$RUNTEST,;t t
13019 s,@AR@,$AR,;t t
13020 s,@AS@,$AS,;t t
13021 s,@DLLTOOL@,$DLLTOOL,;t t
13022 s,@LD@,$LD,;t t
13023 s,@LIPO@,$LIPO,;t t
13024 s,@NM@,$NM,;t t
13025 s,@RANLIB@,$RANLIB,;t t
13026 s,@STRIP@,$STRIP,;t t
13027 s,@WINDRES@,$WINDRES,;t t
13028 s,@WINDMC@,$WINDMC,;t t
13029 s,@OBJCOPY@,$OBJCOPY,;t t
13030 s,@OBJDUMP@,$OBJDUMP,;t t
13031 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13032 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13033 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13034 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13035 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13036 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13037 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13038 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13039 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13040 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13041 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13042 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13043 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13044 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13045 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13046 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13047 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13048 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13049 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13050 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13051 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13052 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13053 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13054 s,@MAINT@,$MAINT,;t t
13055 s,@stage1_cflags@,$stage1_cflags,;t t
13056 s,@stage1_checking@,$stage1_checking,;t t
13057 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13058 s,@datarootdir@,$datarootdir,;t t
13059 s,@docdir@,$docdir,;t t
13060 s,@pdfdir@,$pdfdir,;t t
13061 s,@htmldir@,$htmldir,;t t
13062 s,@LIBOBJS@,$LIBOBJS,;t t
13063 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13064 /@serialization_dependencies@/r $serialization_dependencies
13065 s,@serialization_dependencies@,,;t t
13066 /@host_makefile_frag@/r $host_makefile_frag
13067 s,@host_makefile_frag@,,;t t
13068 /@target_makefile_frag@/r $target_makefile_frag
13069 s,@target_makefile_frag@,,;t t
13070 /@alphaieee_frag@/r $alphaieee_frag
13071 s,@alphaieee_frag@,,;t t
13072 /@ospace_frag@/r $ospace_frag
13073 s,@ospace_frag@,,;t t
13074 CEOF
13075
13076 _ACEOF
13077
13078   cat >>$CONFIG_STATUS <<\_ACEOF
13079   # Split the substitutions into bite-sized pieces for seds with
13080   # small command number limits, like on Digital OSF/1 and HP-UX.
13081   ac_max_sed_lines=48
13082   ac_sed_frag=1 # Number of current file.
13083   ac_beg=1 # First line for current file.
13084   ac_end=$ac_max_sed_lines # Line after last line for current file.
13085   ac_more_lines=:
13086   ac_sed_cmds=
13087   while $ac_more_lines; do
13088     if test $ac_beg -gt 1; then
13089       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13090     else
13091       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13092     fi
13093     if test ! -s $tmp/subs.frag; then
13094       ac_more_lines=false
13095     else
13096       # The purpose of the label and of the branching condition is to
13097       # speed up the sed processing (if there are no `@' at all, there
13098       # is no need to browse any of the substitutions).
13099       # These are the two extra sed commands mentioned above.
13100       (echo ':t
13101   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13102       if test -z "$ac_sed_cmds"; then
13103         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13104       else
13105         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13106       fi
13107       ac_sed_frag=`expr $ac_sed_frag + 1`
13108       ac_beg=$ac_end
13109       ac_end=`expr $ac_end + $ac_max_sed_lines`
13110     fi
13111   done
13112   if test -z "$ac_sed_cmds"; then
13113     ac_sed_cmds=cat
13114   fi
13115 fi # test -n "$CONFIG_FILES"
13116
13117 _ACEOF
13118 cat >>$CONFIG_STATUS <<\_ACEOF
13119 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13120   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13121   case $ac_file in
13122   - | *:- | *:-:* ) # input from stdin
13123         cat >$tmp/stdin
13124         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13125         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13126   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13127         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13128   * )   ac_file_in=$ac_file.in ;;
13129   esac
13130
13131   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13132   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13133 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13134          X"$ac_file" : 'X\(//\)[^/]' \| \
13135          X"$ac_file" : 'X\(//\)$' \| \
13136          X"$ac_file" : 'X\(/\)' \| \
13137          .     : '\(.\)' 2>/dev/null ||
13138 echo X"$ac_file" |
13139     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13140           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13141           /^X\(\/\/\)$/{ s//\1/; q; }
13142           /^X\(\/\).*/{ s//\1/; q; }
13143           s/.*/./; q'`
13144   { if $as_mkdir_p; then
13145     mkdir -p "$ac_dir"
13146   else
13147     as_dir="$ac_dir"
13148     as_dirs=
13149     while test ! -d "$as_dir"; do
13150       as_dirs="$as_dir $as_dirs"
13151       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13152 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13153          X"$as_dir" : 'X\(//\)[^/]' \| \
13154          X"$as_dir" : 'X\(//\)$' \| \
13155          X"$as_dir" : 'X\(/\)' \| \
13156          .     : '\(.\)' 2>/dev/null ||
13157 echo X"$as_dir" |
13158     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13159           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13160           /^X\(\/\/\)$/{ s//\1/; q; }
13161           /^X\(\/\).*/{ s//\1/; q; }
13162           s/.*/./; q'`
13163     done
13164     test ! -n "$as_dirs" || mkdir $as_dirs
13165   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13166 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13167    { (exit 1); exit 1; }; }; }
13168
13169   ac_builddir=.
13170
13171 if test "$ac_dir" != .; then
13172   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13173   # A "../" for each directory in $ac_dir_suffix.
13174   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13175 else
13176   ac_dir_suffix= ac_top_builddir=
13177 fi
13178
13179 case $srcdir in
13180   .)  # No --srcdir option.  We are building in place.
13181     ac_srcdir=.
13182     if test -z "$ac_top_builddir"; then
13183        ac_top_srcdir=.
13184     else
13185        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13186     fi ;;
13187   [\\/]* | ?:[\\/]* )  # Absolute path.
13188     ac_srcdir=$srcdir$ac_dir_suffix;
13189     ac_top_srcdir=$srcdir ;;
13190   *) # Relative path.
13191     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13192     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13193 esac
13194
13195 # Do not use `cd foo && pwd` to compute absolute paths, because
13196 # the directories may not exist.
13197 case `pwd` in
13198 .) ac_abs_builddir="$ac_dir";;
13199 *)
13200   case "$ac_dir" in
13201   .) ac_abs_builddir=`pwd`;;
13202   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13203   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13204   esac;;
13205 esac
13206 case $ac_abs_builddir in
13207 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13208 *)
13209   case ${ac_top_builddir}. in
13210   .) ac_abs_top_builddir=$ac_abs_builddir;;
13211   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13212   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13213   esac;;
13214 esac
13215 case $ac_abs_builddir in
13216 .) ac_abs_srcdir=$ac_srcdir;;
13217 *)
13218   case $ac_srcdir in
13219   .) ac_abs_srcdir=$ac_abs_builddir;;
13220   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13221   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13222   esac;;
13223 esac
13224 case $ac_abs_builddir in
13225 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13226 *)
13227   case $ac_top_srcdir in
13228   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13229   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13230   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13231   esac;;
13232 esac
13233
13234
13235   case $INSTALL in
13236   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13237   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13238   esac
13239
13240   if test x"$ac_file" != x-; then
13241     { echo "$as_me:$LINENO: creating $ac_file" >&5
13242 echo "$as_me: creating $ac_file" >&6;}
13243     rm -f "$ac_file"
13244   fi
13245   # Let's still pretend it is `configure' which instantiates (i.e., don't
13246   # use $as_me), people would be surprised to read:
13247   #    /* config.h.  Generated by config.status.  */
13248   if test x"$ac_file" = x-; then
13249     configure_input=
13250   else
13251     configure_input="$ac_file.  "
13252   fi
13253   configure_input=$configure_input"Generated from `echo $ac_file_in |
13254                                      sed 's,.*/,,'` by configure."
13255
13256   # First look for the input files in the build tree, otherwise in the
13257   # src tree.
13258   ac_file_inputs=`IFS=:
13259     for f in $ac_file_in; do
13260       case $f in
13261       -) echo $tmp/stdin ;;
13262       [\\/$]*)
13263          # Absolute (can't be DOS-style, as IFS=:)
13264          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13265 echo "$as_me: error: cannot find input file: $f" >&2;}
13266    { (exit 1); exit 1; }; }
13267          echo "$f";;
13268       *) # Relative
13269          if test -f "$f"; then
13270            # Build tree
13271            echo "$f"
13272          elif test -f "$srcdir/$f"; then
13273            # Source tree
13274            echo "$srcdir/$f"
13275          else
13276            # /dev/null tree
13277            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13278 echo "$as_me: error: cannot find input file: $f" >&2;}
13279    { (exit 1); exit 1; }; }
13280          fi;;
13281       esac
13282     done` || { (exit 1); exit 1; }
13283 _ACEOF
13284 cat >>$CONFIG_STATUS <<_ACEOF
13285   sed "$ac_vpsub
13286 $extrasub
13287 _ACEOF
13288 cat >>$CONFIG_STATUS <<\_ACEOF
13289 :t
13290 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13291 s,@configure_input@,$configure_input,;t t
13292 s,@srcdir@,$ac_srcdir,;t t
13293 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13294 s,@top_srcdir@,$ac_top_srcdir,;t t
13295 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13296 s,@builddir@,$ac_builddir,;t t
13297 s,@abs_builddir@,$ac_abs_builddir,;t t
13298 s,@top_builddir@,$ac_top_builddir,;t t
13299 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13300 s,@INSTALL@,$ac_INSTALL,;t t
13301 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13302   rm -f $tmp/stdin
13303   if test x"$ac_file" != x-; then
13304     mv $tmp/out $ac_file
13305   else
13306     cat $tmp/out
13307     rm -f $tmp/out
13308   fi
13309
13310 done
13311 _ACEOF
13312
13313 cat >>$CONFIG_STATUS <<\_ACEOF
13314
13315 { (exit 0); exit 0; }
13316 _ACEOF
13317 chmod +x $CONFIG_STATUS
13318 ac_clean_files=$ac_clean_files_save
13319
13320
13321 # configure is writing to config.log, and then calls config.status.
13322 # config.status does its own redirection, appending to config.log.
13323 # Unfortunately, on DOS this fails, as config.log is still kept open
13324 # by configure, so config.status won't be able to write to it; its
13325 # output is simply discarded.  So we exec the FD to /dev/null,
13326 # effectively closing config.log, so it can be properly (re)opened and
13327 # appended to by config.status.  When coming back to configure, we
13328 # need to make the FD available again.
13329 if test "$no_create" != yes; then
13330   ac_cs_success=:
13331   ac_config_status_args=
13332   test "$silent" = yes &&
13333     ac_config_status_args="$ac_config_status_args --quiet"
13334   exec 5>/dev/null
13335   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13336   exec 5>>config.log
13337   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13338   # would make configure fail if this is the last instruction.
13339   $ac_cs_success || { (exit 1); exit 1; }
13340 fi
13341